No OneTemporary
Actions

Size

7 MB

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	Index: trunk/examples/Python/brute_force_kde_1d.py
	===================================================================
	--- trunk/examples/Python/brute_force_kde_1d.py (revision 618)
	+++ trunk/examples/Python/brute_force_kde_1d.py (revision 619)
	@@ -1,125 +1,127 @@
	#!/usr/bin/env python3
	"""
	This example illistrates how to perform constant-bandwidth univariate
	-kernel density estimation (KDE) with NPStat with a brute-force calculation.
	-This kind of calculation is useful for relatively small sample sizes.
	+kernel density estimation (KDE) with a brute-force calculation using
	+the NPStat package. The KDE bandwidth is chosen by cross-validation (CV).
	+This kind of calculation works for relatively small sample sizes as the
	+CV computational complexity is proportional to the sample size squared.
	"""

	__author__="Igor Volobouev (i.volobouev@ttu.edu)"
	__version__="1.1"
	__date__ ="Sep 15 2019"

	# Perform necessary imports
	import npstat as ns
	from npstat_utils import HistoND
	import matplotlib.pyplot as plt
	import numpy as np
	import math

	# Some parameters for the script
	sampleSize = 100 # Number of points to generate (sample size)
	xmin = -3.5 # Left edge of the sample histogram
	xmax = 3.5 # Right edge of the sample histogram
	numBins = 35 # Number of bins for the sample histogram
	scanPoints = 701 # Number of points to use for density scans
	symbetaPower = 4 # Power parameter of the symmetric beta function used as
	# the kernel. Use -1 to create a Gaussian kernel instead.
	filterDegree = 0 # Degree of polynomial used to generate high-order kernels.
	# In general, even numbers make the most sense here.
	# Kernel order will then be filterDegree + 2. The
	# kernel will be a bona-fide density (i.e., non-negative
	# everywhere) only if filterDegree is 0.

	# We will use a 1-d Gassian mixture to generate the random sample. The
	# components of such a mixture are described by the "GaussianMixtureEntry"
	# class. GaussianMixtureEntry constructor takes three arguments: the
	# weight of the component, the mean of the Gaussian, and the standard
	# deviation. Weights can not be negative and the standard deviations
	# must be positive. The sum of the weights will be normalized internally.
	component1 = ns.GaussianMixtureEntry(3.0, -1.0, 0.5)
	component2 = ns.GaussianMixtureEntry(7.0, 1.0, 0.5)
	mixture = ns.GaussianMixture1D(0.0, 1.0, (component1, component2))

	# Generate a random sample according to the Gassian mixture density
	rng = ns.MersenneTwister()
	sample = mixture.generate(rng, sampleSize)

	# Histogram this random sample
	h1 = HistoND("int", ns.HistoAxis(numBins, xmin, xmax, "X"),
	"Sample Histogram", "Counts")
	any(h1.fill(x, 1) for x in sample)

	# Create the kernel that will be used to perform KDE
	kernel = ns.KDE1DHOSymbetaKernel(symbetaPower, filterDegree)

	# Create the estimator of the density
	kde = ns.DoubleKDE1D(kernel, sample)

	# Make an initial guess for the KDE bandwidth. First, calculate
	# a robust measure of the sample scale.
	acc = ns.DoubleSampleAccumulator()
	acc.accumulateAll(sample)
	scale = acc.sigmaRange()

	# Now, use the robust scale to make a bandwidth guess
	# with the so-called plug-in method
	if symbetaPower >= 0:
	bw0 = ns.amisePluginBwSymbeta(symbetaPower, filterDegree, sampleSize, scale)
	else:
	bw0 = ns.amisePluginBwGauss(filterDegree, sampleSize, scale)
	print("Plug-in bandwidth is", bw0)

	# Using the initial bandwidth guess, choose bandwidth by cross-validation.
	# We can use some numerical optimization method (e.g., scipy.optimize), but
	# here we will perform just a simple bandwidth scan. Note that for brute-force
	# KDE the time of cross-validation calculations scales as O(sampleSize^2).
	bwValues = np.logspace(math.log10(bw0/4.0), math.log10(bw0*2.0), 100)

	# Run the regularized likelihood cross-validation (RLCV).
	# For the description of this method, see section 4.2 in
	# https://doi.org/10.1080/10485252.2017.1371715
	regularisationParameter = 0.5
	rlcvFunctor = kde.rlcvFunctor(regularisationParameter)
	rlcv, rlcvBandwidth = max([(rlcvFunctor(bw), bw) for bw in bwValues])
	print("RLCV bandwidth is", rlcvBandwidth)

	# Run the least squares cross-validation (LSCV). For this type of CV,
	# the code will need to calculate the integral of density estimate squared.
	# The parameters of the "lscvFunctor" method specify how this integration
	# will be performed. The method signature is
	#
	# lscvFunctor(xmin, xmax, nSubIntervals, nPoints)
	#
	# The interval of integration will be [xmin, xmax]. This interval will
	# be split into "nSubIntervals" subintervals, and the Gauss-Legendre
	# quadrature rule with "nPoints" points will be utilized on each subinterval.
	lscvFunctor = kde.lscvFunctor(2xmin, 2xmax, 1, 256)
	lscv, lscvBandwidth = max([(lscvFunctor(bw), bw) for bw in bwValues])
	print("LSCV bandwidth is", lscvBandwidth)

	# Plot the sample histogram
	xh, yh = ns.histoOutline1D(h1)
	plt.plot(xh, yh, 'k')

	# Overlay the original density. Scale all densities so that their
	# plots are compatible with the histogram height.
	verticalScale = h1.binVolume()*sampleSize
	xdens, ydens = ns.scanDensity1D(mixture, xmin, xmax, scanPoints)
	plt.plot(xdens, ydens*verticalScale, 'g', label='True density')

	# Overlay the KDE results with various bandwidth values
	bandwidths = (bw0, rlcvBandwidth, lscvBandwidth)
	colors = ('c', 'r', 'b' )
	labels = ('Plug-in', 'RLCV', 'LSCV' )
	for bw, color, l in zip(bandwidths, colors, labels):
	x, y = ns.scanKDE1D(kde, xmin, xmax, scanPoints, bw)
	plt.plot(x, y*verticalScale, color, label="{} estimate".format(l))

	# Add labels and comments
	plt.xlabel('X')
	plt.ylabel('Density estimate')
	plt.title('Brute-Force KDE')
	plt.legend(loc=2)

	# Display the window
	plt.show()
	Index: trunk/examples/Python/kde_1d_by_fft.py
	===================================================================
	--- trunk/examples/Python/kde_1d_by_fft.py (revision 0)
	+++ trunk/examples/Python/kde_1d_by_fft.py (revision 619)
	@@ -0,0 +1,92 @@
	+#!/usr/bin/env python3
	+"""
	+This example illistrates how to perform constant-bandwidth univariate
	+kernel density estimation (KDE) utilizing fast Fourier transforms (FFT)
	+with the help of the NPStat package.
	+"""
	+
	+__author__="Igor Volobouev (i.volobouev@ttu.edu)"
	+__version__="1.0"
	+__date__ ="Sep 17 2019"
	+
	+# Perform necessary imports
	+import npstat as ns
	+from npstat_utils import HistoND
	+import matplotlib.pyplot as plt
	+
	+# Some parameters for the script
	+sampleSize = 500 # Number of points to generate (sample size)
	+xmin = -3.5 # Left edge of the sample histogram
	+xmax = 3.5 # Right edge of the sample histogram
	+numBins = 70 # Number of bins for the sample histogram
	+nDiscrete = 1024 # Number of cells for sample discretization.
	+ # Should be a power of 2 (this results in the
	+ # most efficient application of FFT).
	+symbetaPower = -1 # Power parameter of the symmetric beta kernel.
	+ # Specify -1 to use a Gaussian kernel instead.
	+kernelOrder = 4 # The order of the kernel. Meaningful arguments
	+ # are even numbers 2 or larger.
	+bwFactor = 0.5 # KDE bandwidth will be set to the product of the
	+ # plug-in bandwidth and this factor. The choice
	+ # of the factor is empirical here.
	+
	+# We will use a 1-d Gassian mixture to generate the random sample.
	+# See the "brute_force_kde_1d.py" script for more comments on this.
	+component1 = ns.GaussianMixtureEntry(3.0, -1.0, 0.5)
	+component2 = ns.GaussianMixtureEntry(7.0, 1.0, 0.5)
	+mixture = ns.GaussianMixture1D(0.0, 1.0, (component1, component2))
	+
	+# Generate a random sample according to this density
	+rng = ns.MersenneTwister()
	+sample = mixture.generate(rng, sampleSize)
	+
	+# Histogram for displaying the sample
	+h1 = HistoND("int", ns.HistoAxis(numBins, xmin, xmax, "X"),
	+ "Sample Histogram", "Counts")
	+any(h1.fill(x, 1) for x in sample)
	+
	+# Object which will perform KDE. For smoothing purposes, the bin width
	+# should be substantially smaller than any physical scale of interest.
	+# If "bandwidthGuess" argument is positive, it will be used as the KDE
	+# bandwidth. If it is 0, the product of the plug-in bandwidth and bwFactor
	+# will be used instead.
	+bandwidthGuess = 0.0
	+smoother = ns.ConstantBandwidthSmoother1D(nDiscrete, 2xmin, 2xmax,
	+ symbetaPower, kernelOrder,
	+ bandwidthGuess, bwFactor);
	+
	+# Perform KDE. The "smooth" method will return the smoothed histogram
	+# whose area is normalized to 1 (this will be a SWIG-wrapped object of
	+# C++ type npstat::HistoND<double>) and the bandwidth used.
	+hkde, bw = smoother.smooth(sample)
	+print("KDE bandwidth is", bw)
	+
	+# Create Matplotlib plot window
	+fig = plt.figure()
	+ax = fig.add_subplot(111)
	+
	+# Plot the sample histogram
	+xh, yh = ns.histoOutline1D(h1)
	+ax.plot(xh, yh, 'k')
	+
	+# Overlay the original density. Scale all densities so that their
	+# plots are compatible with the histogram height.
	+verticalScale = h1.binVolume()*sampleSize
	+xdens, ydens = ns.scanDensity1D(mixture, xmin, xmax, nDiscrete+1)
	+ax.plot(xdens, ydens*verticalScale, 'g', label='True density')
	+
	+# Overlay the LOrPE result. Scale it to the area of the histogram.
	+ykde = ns.arrayNDToNumpy(hkde.binContents())
	+ax.plot(hkde.axis(0).binCenters(), ykde*verticalScale, 'r', label='KDE')
	+
	+# Set the x range of the plot to that of the sample histogram
	+ax.set_xlim(h1.axis(0).min(), h1.axis(0).max())
	+
	+# Add labels and comments
	+plt.xlabel('X')
	+plt.ylabel('Density')
	+plt.title('KDE by FFT')
	+plt.legend(loc=2)
	+
	+# Display the window
	+plt.show()

	Property changes on: trunk/examples/Python/kde_1d_by_fft.py
	___________________________________________________________________
	Added: svn:executable
	## -0,0 +1 ##
	+*
	\ No newline at end of property
	Index: trunk/npstat/swig/npstat.py
	===================================================================
	--- trunk/npstat/swig/npstat.py (revision 618)
	+++ trunk/npstat/swig/npstat.py (revision 619)
	@@ -1,39626 +1,39626 @@
	# This file was automatically generated by SWIG (http://www.swig.org).
	# Version 3.0.12
	#
	# Do not make changes to this file unless you know what you are doing--modify
	# the SWIG interface file instead.

	from sys import version_info as _swig_python_version_info
	if _swig_python_version_info >= (2, 7, 0):
	def swig_import_helper():
	import importlib
	pkg = __name__.rpartition('.')[0]
	mname = '.'.join((pkg, '_npstat')).lstrip('.')
	try:
	return importlib.import_module(mname)
	except ImportError:
	return importlib.import_module('_npstat')
	_npstat = swig_import_helper()
	del swig_import_helper
	elif _swig_python_version_info >= (2, 6, 0):
	def swig_import_helper():
	from os.path import dirname
	import imp
	fp = None
	try:
	fp, pathname, description = imp.find_module('_npstat', [dirname(__file__)])
	except ImportError:
	import _npstat
	return _npstat
	try:
	_mod = imp.load_module('_npstat', fp, pathname, description)
	finally:
	if fp is not None:
	fp.close()
	return _mod
	_npstat = swig_import_helper()
	del swig_import_helper
	else:
	import _npstat
	del _swig_python_version_info

	try:
	_swig_property = property
	except NameError:
	pass # Python < 2.2 doesn't have 'property'.

	try:
	import builtins as __builtin__
	except ImportError:
	import __builtin__

	def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
	if (name == "thisown"):
	return self.this.own(value)
	if (name == "this"):
	if type(value).__name__ == 'SwigPyObject':
	self.__dict__[name] = value
	return
	method = class_type.__swig_setmethods__.get(name, None)
	if method:
	return method(self, value)
	if (not static):
	if _newclass:
	object.__setattr__(self, name, value)
	else:
	self.__dict__[name] = value
	else:
	raise AttributeError("You cannot add attributes to %s" % self)


	def _swig_setattr(self, class_type, name, value):
	return _swig_setattr_nondynamic(self, class_type, name, value, 0)


	def _swig_getattr(self, class_type, name):
	if (name == "thisown"):
	return self.this.own()
	method = class_type.__swig_getmethods__.get(name, None)
	if method:
	return method(self)
	raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


	def _swig_repr(self):
	try:
	strthis = "proxy of " + self.this.__repr__()
	except __builtin__.Exception:
	strthis = ""
	return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

	try:
	_object = object
	_newclass = 1
	except __builtin__.Exception:
	class _object:
	pass
	_newclass = 0

	class SwigPyIterator(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_SwigPyIterator
	__del__ = lambda self: None

	def value(self) -> "PyObject *":
	return _npstat.SwigPyIterator_value(self)

	def incr(self, n: 'size_t'=1) -> "swig::SwigPyIterator *":
	return _npstat.SwigPyIterator_incr(self, n)

	def decr(self, n: 'size_t'=1) -> "swig::SwigPyIterator *":
	return _npstat.SwigPyIterator_decr(self, n)

	def distance(self, x: 'SwigPyIterator') -> "ptrdiff_t":
	return _npstat.SwigPyIterator_distance(self, x)

	def equal(self, x: 'SwigPyIterator') -> "bool":
	return _npstat.SwigPyIterator_equal(self, x)

	def copy(self) -> "swig::SwigPyIterator *":
	return _npstat.SwigPyIterator_copy(self)

	def next(self) -> "PyObject *":
	return _npstat.SwigPyIterator_next(self)

	def __next__(self) -> "PyObject *":
	return _npstat.SwigPyIterator___next__(self)

	def previous(self) -> "PyObject *":
	return _npstat.SwigPyIterator_previous(self)

	def advance(self, n: 'ptrdiff_t') -> "swig::SwigPyIterator *":
	return _npstat.SwigPyIterator_advance(self, n)

	def __eq__(self, x: 'SwigPyIterator') -> "bool":
	return _npstat.SwigPyIterator___eq__(self, x)

	def __ne__(self, x: 'SwigPyIterator') -> "bool":
	return _npstat.SwigPyIterator___ne__(self, x)

	def __iadd__(self, n: 'ptrdiff_t') -> "swig::SwigPyIterator &":
	return _npstat.SwigPyIterator___iadd__(self, n)

	def __isub__(self, n: 'ptrdiff_t') -> "swig::SwigPyIterator &":
	return _npstat.SwigPyIterator___isub__(self, n)

	def __add__(self, n: 'ptrdiff_t') -> "swig::SwigPyIterator *":
	return _npstat.SwigPyIterator___add__(self, n)

	def __sub__(self, *args) -> "ptrdiff_t":
	return _npstat.SwigPyIterator___sub__(self, *args)
	def __iter__(self):
	return self
	SwigPyIterator_swigregister = _npstat.SwigPyIterator_swigregister
	SwigPyIterator_swigregister(SwigPyIterator)

	class string(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, string, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, string, name)
	__repr__ = _swig_repr

	def length(self) -> "std::basic_string< char >::size_type":
	return _npstat.string_length(self)

	def max_size(self) -> "std::basic_string< char >::size_type":
	return _npstat.string_max_size(self)

	def capacity(self) -> "std::basic_string< char >::size_type":
	return _npstat.string_capacity(self)

	def reserve(self, __res_arg: 'std::basic_string< char >::size_type'=0) -> "void":
	return _npstat.string_reserve(self, __res_arg)

	def copy(self, __s: 'char *', __n: 'std::basic_string< char >::size_type', __pos: 'std::basic_string< char >::size_type'=0) -> "std::basic_string< char >::size_type":
	return _npstat.string_copy(self, __s, __n, __pos)

	def c_str(self) -> "char const *":
	return _npstat.string_c_str(self)

	def find(self, *args) -> "std::basic_string< char >::size_type":
	return _npstat.string_find(self, *args)

	def rfind(self, *args) -> "std::basic_string< char >::size_type":
	return _npstat.string_rfind(self, *args)

	def find_first_of(self, *args) -> "std::basic_string< char >::size_type":
	return _npstat.string_find_first_of(self, *args)

	def find_last_of(self, *args) -> "std::basic_string< char >::size_type":
	return _npstat.string_find_last_of(self, *args)

	def find_first_not_of(self, *args) -> "std::basic_string< char >::size_type":
	return _npstat.string_find_first_not_of(self, *args)

	def find_last_not_of(self, *args) -> "std::basic_string< char >::size_type":
	return _npstat.string_find_last_not_of(self, *args)

	def substr(self, *args) -> "std::basic_string< char >":
	return _npstat.string_substr(self, *args)

	def empty(self) -> "bool":
	return _npstat.string_empty(self)

	def size(self) -> "std::basic_string< char >::size_type":
	return _npstat.string_size(self)

	def swap(self, v: 'string') -> "void":
	return _npstat.string_swap(self, v)

	def begin(self) -> "std::basic_string< char >::iterator":
	return _npstat.string_begin(self)

	def end(self) -> "std::basic_string< char >::iterator":
	return _npstat.string_end(self)

	def rbegin(self) -> "std::basic_string< char >::reverse_iterator":
	return _npstat.string_rbegin(self)

	def rend(self) -> "std::basic_string< char >::reverse_iterator":
	return _npstat.string_rend(self)

	def get_allocator(self) -> "std::basic_string< char >::allocator_type":
	return _npstat.string_get_allocator(self)

	def erase(self, *args) -> "std::basic_string< char >::iterator":
	return _npstat.string_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_string(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def assign(self, *args) -> "void":
	return _npstat.string_assign(self, *args)

	def resize(self, *args) -> "void":
	return _npstat.string_resize(self, *args)

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.string_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.string___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.string___bool__(self)

	def __len__(self) -> "std::basic_string< char >::size_type":
	return _npstat.string___len__(self)

	def __getslice__(self, i: 'std::basic_string< char >::difference_type', j: 'std::basic_string< char >::difference_type') -> "std::basic_string< char,std::char_traits< char >,std::allocator< char > > *":
	return _npstat.string___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.string___setslice__(self, *args)

	def __delslice__(self, i: 'std::basic_string< char >::difference_type', j: 'std::basic_string< char >::difference_type') -> "void":
	return _npstat.string___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.string___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::basic_string< char >::value_type":
	return _npstat.string___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.string___setitem__(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.string_insert(self, *args)

	def replace(self, *args) -> "std::basic_string< char > &":
	return _npstat.string_replace(self, *args)

	def __iadd__(self, v: 'string') -> "std::basic_string< char > &":
	return _npstat.string___iadd__(self, v)

	def __add__(self, v: 'string') -> "std::basic_string< char,std::char_traits< char >,std::allocator< char > > *":
	return _npstat.string___add__(self, v)

	def __radd__(self, v: 'string') -> "std::basic_string< char,std::char_traits< char >,std::allocator< char > > *":
	return _npstat.string___radd__(self, v)

	def __str__(self) -> "std::basic_string< char,std::char_traits< char >,std::allocator< char > >":
	return _npstat.string___str__(self)

	def __rlshift__(self, out: 'ostream') -> "std::basic_ostream< char,std::char_traits< char > > &":
	return _npstat.string___rlshift__(self, out)

	def __eq__(self, v: 'string') -> "bool":
	return _npstat.string___eq__(self, v)

	def __ne__(self, v: 'string') -> "bool":
	return _npstat.string___ne__(self, v)

	def __gt__(self, v: 'string') -> "bool":
	return _npstat.string___gt__(self, v)

	def __lt__(self, v: 'string') -> "bool":
	return _npstat.string___lt__(self, v)

	def __ge__(self, v: 'string') -> "bool":
	return _npstat.string___ge__(self, v)

	def __le__(self, v: 'string') -> "bool":
	return _npstat.string___le__(self, v)
	__swig_destroy__ = _npstat.delete_string
	__del__ = lambda self: None
	string_swigregister = _npstat.string_swigregister
	string_swigregister(string)
	cvar = _npstat.cvar
	string.npos = _npstat.cvar.string_npos

	class ios_base(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, ios_base, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, ios_base, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined")
	__repr__ = _swig_repr
	erase_event = _npstat.ios_base_erase_event
	imbue_event = _npstat.ios_base_imbue_event
	copyfmt_event = _npstat.ios_base_copyfmt_event

	def register_callback(self, __fn: 'std::ios_base::event_callback', __index: 'int') -> "void":
	return _npstat.ios_base_register_callback(self, __fn, __index)

	def flags(self, *args) -> "std::ios_base::fmtflags":
	return _npstat.ios_base_flags(self, *args)

	def setf(self, *args) -> "std::ios_base::fmtflags":
	return _npstat.ios_base_setf(self, *args)

	def unsetf(self, __mask: 'std::ios_base::fmtflags') -> "void":
	return _npstat.ios_base_unsetf(self, __mask)

	def precision(self, *args) -> "std::streamsize":
	return _npstat.ios_base_precision(self, *args)

	def width(self, *args) -> "std::streamsize":
	return _npstat.ios_base_width(self, *args)
	if _newclass:
	sync_with_stdio = staticmethod(_npstat.ios_base_sync_with_stdio)
	else:
	sync_with_stdio = _npstat.ios_base_sync_with_stdio

	def imbue(self, __loc: 'std::locale const &') -> "std::locale":
	return _npstat.ios_base_imbue(self, __loc)

	def getloc(self) -> "std::locale":
	return _npstat.ios_base_getloc(self)
	if _newclass:
	xalloc = staticmethod(_npstat.ios_base_xalloc)
	else:
	xalloc = _npstat.ios_base_xalloc

	def iword(self, __ix: 'int') -> "long &":
	return _npstat.ios_base_iword(self, __ix)

	def pword(self, __ix: 'int') -> "void *&":
	return _npstat.ios_base_pword(self, __ix)
	__swig_destroy__ = _npstat.delete_ios_base
	__del__ = lambda self: None
	ios_base_swigregister = _npstat.ios_base_swigregister
	ios_base_swigregister(ios_base)
	ios_base.boolalpha = _npstat.cvar.ios_base_boolalpha
	ios_base.dec = _npstat.cvar.ios_base_dec
	ios_base.fixed = _npstat.cvar.ios_base_fixed
	ios_base.hex = _npstat.cvar.ios_base_hex
	ios_base.internal = _npstat.cvar.ios_base_internal
	ios_base.left = _npstat.cvar.ios_base_left
	ios_base.oct = _npstat.cvar.ios_base_oct
	ios_base.right = _npstat.cvar.ios_base_right
	ios_base.scientific = _npstat.cvar.ios_base_scientific
	ios_base.showbase = _npstat.cvar.ios_base_showbase
	ios_base.showpoint = _npstat.cvar.ios_base_showpoint
	ios_base.showpos = _npstat.cvar.ios_base_showpos
	ios_base.skipws = _npstat.cvar.ios_base_skipws
	ios_base.unitbuf = _npstat.cvar.ios_base_unitbuf
	ios_base.uppercase = _npstat.cvar.ios_base_uppercase
	ios_base.adjustfield = _npstat.cvar.ios_base_adjustfield
	ios_base.basefield = _npstat.cvar.ios_base_basefield
	ios_base.floatfield = _npstat.cvar.ios_base_floatfield
	ios_base.badbit = _npstat.cvar.ios_base_badbit
	ios_base.eofbit = _npstat.cvar.ios_base_eofbit
	ios_base.failbit = _npstat.cvar.ios_base_failbit
	ios_base.goodbit = _npstat.cvar.ios_base_goodbit
	ios_base.app = _npstat.cvar.ios_base_app
	ios_base.ate = _npstat.cvar.ios_base_ate
	ios_base.binary = _npstat.cvar.ios_base_binary
	ios_base.ios_base_in = _npstat.cvar.ios_base_ios_base_in
	ios_base.out = _npstat.cvar.ios_base_out
	ios_base.trunc = _npstat.cvar.ios_base_trunc
	ios_base.beg = _npstat.cvar.ios_base_beg
	ios_base.cur = _npstat.cvar.ios_base_cur
	ios_base.end = _npstat.cvar.ios_base_end

	def ios_base_sync_with_stdio(__sync: 'bool'=True) -> "bool":
	return _npstat.ios_base_sync_with_stdio(__sync)
	ios_base_sync_with_stdio = _npstat.ios_base_sync_with_stdio

	def ios_base_xalloc() -> "int":
	return _npstat.ios_base_xalloc()
	ios_base_xalloc = _npstat.ios_base_xalloc

	class ios(ios_base):
	__swig_setmethods__ = {}
	for _s in [ios_base]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ios, name, value)
	__swig_getmethods__ = {}
	for _s in [ios_base]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ios, name)
	__repr__ = _swig_repr

	def rdstate(self) -> "std::ios_base::iostate":
	return _npstat.ios_rdstate(self)

	def clear(self, *args) -> "void":
	return _npstat.ios_clear(self, *args)

	def setstate(self, __state: 'std::ios_base::iostate') -> "void":
	return _npstat.ios_setstate(self, __state)

	def good(self) -> "bool":
	return _npstat.ios_good(self)

	def eof(self) -> "bool":
	return _npstat.ios_eof(self)

	def fail(self) -> "bool":
	return _npstat.ios_fail(self)

	def bad(self) -> "bool":
	return _npstat.ios_bad(self)

	def exceptions(self, *args) -> "void":
	return _npstat.ios_exceptions(self, *args)

	def __init__(self, __sb: 'streambuf'):
	this = _npstat.new_ios(__sb)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ios
	__del__ = lambda self: None

	def tie(self, args) -> "std::basic_ostream< char,std::char_traits< char > > ":
	return _npstat.ios_tie(self, *args)

	def rdbuf(self, args) -> "std::basic_streambuf< char,std::char_traits< char > > ":
	return _npstat.ios_rdbuf(self, *args)

	def copyfmt(self, __rhs: 'ios') -> "std::basic_ios< char > &":
	return _npstat.ios_copyfmt(self, __rhs)

	def fill(self, *args) -> "std::basic_ios< char >::char_type":
	return _npstat.ios_fill(self, *args)

	def imbue(self, __loc: 'std::locale const &') -> "std::locale":
	return _npstat.ios_imbue(self, __loc)

	def narrow(self, __c: 'std::basic_ios< char >::char_type', __dfault: 'char') -> "char":
	return _npstat.ios_narrow(self, __c, __dfault)

	def widen(self, __c: 'char') -> "std::basic_ios< char >::char_type":
	return _npstat.ios_widen(self, __c)
	ios_swigregister = _npstat.ios_swigregister
	ios_swigregister(ios)

	class streambuf(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, streambuf, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, streambuf, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_streambuf
	__del__ = lambda self: None

	def pubimbue(self, __loc: 'std::locale const &') -> "std::locale":
	return _npstat.streambuf_pubimbue(self, __loc)

	def getloc(self) -> "std::locale":
	return _npstat.streambuf_getloc(self)

	def pubsetbuf(self, __s: 'std::basic_streambuf< char >::char_type ', __n: 'std::streamsize') -> "std::basic_streambuf< char,std::char_traits< char > > ":
	return _npstat.streambuf_pubsetbuf(self, __s, __n)

	def pubseekoff(self, *args) -> "std::basic_streambuf< char >::pos_type":
	return _npstat.streambuf_pubseekoff(self, *args)

	def pubseekpos(self, *args) -> "std::basic_streambuf< char >::pos_type":
	return _npstat.streambuf_pubseekpos(self, *args)

	def pubsync(self) -> "int":
	return _npstat.streambuf_pubsync(self)

	def in_avail(self) -> "std::streamsize":
	return _npstat.streambuf_in_avail(self)

	def snextc(self) -> "std::basic_streambuf< char >::int_type":
	return _npstat.streambuf_snextc(self)

	def sbumpc(self) -> "std::basic_streambuf< char >::int_type":
	return _npstat.streambuf_sbumpc(self)

	def sgetc(self) -> "std::basic_streambuf< char >::int_type":
	return _npstat.streambuf_sgetc(self)

	def sgetn(self, __s: 'std::basic_streambuf< char >::char_type *', __n: 'std::streamsize') -> "std::streamsize":
	return _npstat.streambuf_sgetn(self, __s, __n)

	def sputbackc(self, __c: 'std::basic_streambuf< char >::char_type') -> "std::basic_streambuf< char >::int_type":
	return _npstat.streambuf_sputbackc(self, __c)

	def sungetc(self) -> "std::basic_streambuf< char >::int_type":
	return _npstat.streambuf_sungetc(self)

	def sputc(self, __c: 'std::basic_streambuf< char >::char_type') -> "std::basic_streambuf< char >::int_type":
	return _npstat.streambuf_sputc(self, __c)

	def sputn(self, __s: 'std::basic_streambuf< char >::char_type const *', __n: 'std::streamsize') -> "std::streamsize":
	return _npstat.streambuf_sputn(self, __s, __n)
	streambuf_swigregister = _npstat.streambuf_swigregister
	streambuf_swigregister(streambuf)

	class ostream(ios):
	__swig_setmethods__ = {}
	for _s in [ios]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ostream, name, value)
	__swig_getmethods__ = {}
	for _s in [ios]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ostream, name)
	__repr__ = _swig_repr

	def __init__(self, __sb: 'streambuf'):
	this = _npstat.new_ostream(__sb)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ostream
	__del__ = lambda self: None

	def __lshift__(self, *args) -> "std::basic_ostream< char,std::char_traits< char > > &":
	return _npstat.ostream___lshift__(self, *args)

	def put(self, __c: 'std::basic_ostream< char >::char_type') -> "std::basic_ostream< char,std::char_traits< char > > &":
	return _npstat.ostream_put(self, __c)

	def write(self, __s: 'std::basic_ostream< char >::char_type const *', __n: 'std::streamsize') -> "std::basic_ostream< char,std::char_traits< char > > &":
	return _npstat.ostream_write(self, __s, __n)

	def flush(self) -> "std::basic_ostream< char,std::char_traits< char > > &":
	return _npstat.ostream_flush(self)

	def tellp(self) -> "std::basic_ostream< char >::pos_type":
	return _npstat.ostream_tellp(self)

	def seekp(self, *args) -> "std::basic_ostream< char,std::char_traits< char > > &":
	return _npstat.ostream_seekp(self, *args)
	ostream_swigregister = _npstat.ostream_swigregister
	ostream_swigregister(ostream)
	cin = cvar.cin
	cout = cvar.cout
	cerr = cvar.cerr
	clog = cvar.clog

	class istream(ios):
	__swig_setmethods__ = {}
	for _s in [ios]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, istream, name, value)
	__swig_getmethods__ = {}
	for _s in [ios]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, istream, name)
	__repr__ = _swig_repr

	def __init__(self, __sb: 'streambuf'):
	this = _npstat.new_istream(__sb)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_istream
	__del__ = lambda self: None

	def __rshift__(self, *args) -> "std::basic_istream< char,std::char_traits< char > > &":
	return _npstat.istream___rshift__(self, *args)

	def gcount(self) -> "std::streamsize":
	return _npstat.istream_gcount(self)

	def get(self, *args) -> "std::basic_istream< char,std::char_traits< char > > &":
	return _npstat.istream_get(self, *args)

	def getline(self, *args) -> "std::basic_istream< char,std::char_traits< char > > &":
	return _npstat.istream_getline(self, *args)

	def ignore(self, *args) -> "std::basic_istream< char,std::char_traits< char > > &":
	return _npstat.istream_ignore(self, *args)

	def peek(self) -> "std::basic_istream< char >::int_type":
	return _npstat.istream_peek(self)

	def read(self, __s: 'std::basic_istream< char >::char_type *', __n: 'std::streamsize') -> "std::basic_istream< char,std::char_traits< char > > &":
	return _npstat.istream_read(self, __s, __n)

	def readsome(self, __s: 'std::basic_istream< char >::char_type *', __n: 'std::streamsize') -> "std::streamsize":
	return _npstat.istream_readsome(self, __s, __n)

	def putback(self, __c: 'std::basic_istream< char >::char_type') -> "std::basic_istream< char,std::char_traits< char > > &":
	return _npstat.istream_putback(self, __c)

	def unget(self) -> "std::basic_istream< char,std::char_traits< char > > &":
	return _npstat.istream_unget(self)

	def sync(self) -> "int":
	return _npstat.istream_sync(self)

	def tellg(self) -> "std::basic_istream< char >::pos_type":
	return _npstat.istream_tellg(self)

	def seekg(self, *args) -> "std::basic_istream< char,std::char_traits< char > > &":
	return _npstat.istream_seekg(self, *args)
	istream_swigregister = _npstat.istream_swigregister
	istream_swigregister(istream)

	class iostream(istream, ostream):
	__swig_setmethods__ = {}
	for _s in [istream, ostream]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, iostream, name, value)
	__swig_getmethods__ = {}
	for _s in [istream, ostream]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, iostream, name)
	__repr__ = _swig_repr

	def __init__(self, __sb: 'streambuf'):
	this = _npstat.new_iostream(__sb)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_iostream
	__del__ = lambda self: None
	iostream_swigregister = _npstat.iostream_swigregister
	iostream_swigregister(iostream)

	endl_cb_ptr = _npstat.endl_cb_ptr

	def endl(arg1: 'ostream') -> "std::basic_ostream< char,std::char_traits< char > > &":
	return _npstat.endl(arg1)
	endl = _npstat.endl
	ends_cb_ptr = _npstat.ends_cb_ptr

	def ends(arg1: 'ostream') -> "std::basic_ostream< char,std::char_traits< char > > &":
	return _npstat.ends(arg1)
	ends = _npstat.ends
	flush_cb_ptr = _npstat.flush_cb_ptr

	def flush(arg1: 'ostream') -> "std::basic_ostream< char,std::char_traits< char > > &":
	return _npstat.flush(arg1)
	flush = _npstat.flush
	class istringstream(istream):
	__swig_setmethods__ = {}
	for _s in [istream]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, istringstream, name, value)
	__swig_getmethods__ = {}
	for _s in [istream]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, istringstream, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_istringstream(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_istringstream
	__del__ = lambda self: None

	def rdbuf(self) -> "std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *":
	return _npstat.istringstream_rdbuf(self)

	def str(self, *args) -> "void":
	return _npstat.istringstream_str(self, *args)
	istringstream_swigregister = _npstat.istringstream_swigregister
	istringstream_swigregister(istringstream)

	class ostringstream(ostream):
	__swig_setmethods__ = {}
	for _s in [ostream]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ostringstream, name, value)
	__swig_getmethods__ = {}
	for _s in [ostream]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ostringstream, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_ostringstream(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ostringstream
	__del__ = lambda self: None

	def rdbuf(self) -> "std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *":
	return _npstat.ostringstream_rdbuf(self)

	def str(self) -> "std::basic_string< char,std::char_traits< char >,std::allocator< char > >":
	return _npstat.ostringstream_str(self)
	ostringstream_swigregister = _npstat.ostringstream_swigregister
	ostringstream_swigregister(ostringstream)

	class stringstream(iostream):
	__swig_setmethods__ = {}
	for _s in [iostream]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, stringstream, name, value)
	__swig_getmethods__ = {}
	for _s in [iostream]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, stringstream, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_stringstream(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_stringstream
	__del__ = lambda self: None

	def rdbuf(self) -> "std::basic_stringbuf< char,std::char_traits< char >,std::allocator< char > > *":
	return _npstat.stringstream_rdbuf(self)

	def str(self, *args) -> "void":
	return _npstat.stringstream_str(self, *args)
	stringstream_swigregister = _npstat.stringstream_swigregister
	stringstream_swigregister(stringstream)

	class SCharVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, SCharVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, SCharVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.SCharVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.SCharVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.SCharVector___bool__(self)

	def __len__(self) -> "std::vector< signed char >::size_type":
	return _npstat.SCharVector___len__(self)

	def __getslice__(self, i: 'std::vector< signed char >::difference_type', j: 'std::vector< signed char >::difference_type') -> "std::vector< signed char,std::allocator< signed char > > *":
	return _npstat.SCharVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.SCharVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< signed char >::difference_type', j: 'std::vector< signed char >::difference_type') -> "void":
	return _npstat.SCharVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.SCharVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< signed char >::value_type const &":
	return _npstat.SCharVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.SCharVector___setitem__(self, *args)

	def pop(self) -> "std::vector< signed char >::value_type":
	return _npstat.SCharVector_pop(self)

	def append(self, x: 'std::vector< signed char >::value_type const &') -> "void":
	return _npstat.SCharVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.SCharVector_empty(self)

	def size(self) -> "std::vector< signed char >::size_type":
	return _npstat.SCharVector_size(self)

	def swap(self, v: 'SCharVector') -> "void":
	return _npstat.SCharVector_swap(self, v)

	def begin(self) -> "std::vector< signed char >::iterator":
	return _npstat.SCharVector_begin(self)

	def end(self) -> "std::vector< signed char >::iterator":
	return _npstat.SCharVector_end(self)

	def rbegin(self) -> "std::vector< signed char >::reverse_iterator":
	return _npstat.SCharVector_rbegin(self)

	def rend(self) -> "std::vector< signed char >::reverse_iterator":
	return _npstat.SCharVector_rend(self)

	def clear(self) -> "void":
	return _npstat.SCharVector_clear(self)

	def get_allocator(self) -> "std::vector< signed char >::allocator_type":
	return _npstat.SCharVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.SCharVector_pop_back(self)

	def erase(self, *args) -> "std::vector< signed char >::iterator":
	return _npstat.SCharVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_SCharVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'std::vector< signed char >::value_type const &') -> "void":
	return _npstat.SCharVector_push_back(self, x)

	def front(self) -> "std::vector< signed char >::value_type const &":
	return _npstat.SCharVector_front(self)

	def back(self) -> "std::vector< signed char >::value_type const &":
	return _npstat.SCharVector_back(self)

	def assign(self, n: 'std::vector< signed char >::size_type', x: 'std::vector< signed char >::value_type const &') -> "void":
	return _npstat.SCharVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.SCharVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.SCharVector_insert(self, *args)

	def reserve(self, n: 'std::vector< signed char >::size_type') -> "void":
	return _npstat.SCharVector_reserve(self, n)

	def capacity(self) -> "std::vector< signed char >::size_type":
	return _npstat.SCharVector_capacity(self)
	__swig_destroy__ = _npstat.delete_SCharVector
	__del__ = lambda self: None
	SCharVector_swigregister = _npstat.SCharVector_swigregister
	SCharVector_swigregister(SCharVector)

	class UCharVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.UCharVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.UCharVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.UCharVector___bool__(self)

	def __len__(self) -> "std::vector< unsigned char >::size_type":
	return _npstat.UCharVector___len__(self)

	def __getslice__(self, i: 'std::vector< unsigned char >::difference_type', j: 'std::vector< unsigned char >::difference_type') -> "std::vector< unsigned char,std::allocator< unsigned char > > *":
	return _npstat.UCharVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.UCharVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< unsigned char >::difference_type', j: 'std::vector< unsigned char >::difference_type') -> "void":
	return _npstat.UCharVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.UCharVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< unsigned char >::value_type const &":
	return _npstat.UCharVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.UCharVector___setitem__(self, *args)

	def pop(self) -> "std::vector< unsigned char >::value_type":
	return _npstat.UCharVector_pop(self)

	def append(self, x: 'std::vector< unsigned char >::value_type const &') -> "void":
	return _npstat.UCharVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.UCharVector_empty(self)

	def size(self) -> "std::vector< unsigned char >::size_type":
	return _npstat.UCharVector_size(self)

	def swap(self, v: 'UCharVector') -> "void":
	return _npstat.UCharVector_swap(self, v)

	def begin(self) -> "std::vector< unsigned char >::iterator":
	return _npstat.UCharVector_begin(self)

	def end(self) -> "std::vector< unsigned char >::iterator":
	return _npstat.UCharVector_end(self)

	def rbegin(self) -> "std::vector< unsigned char >::reverse_iterator":
	return _npstat.UCharVector_rbegin(self)

	def rend(self) -> "std::vector< unsigned char >::reverse_iterator":
	return _npstat.UCharVector_rend(self)

	def clear(self) -> "void":
	return _npstat.UCharVector_clear(self)

	def get_allocator(self) -> "std::vector< unsigned char >::allocator_type":
	return _npstat.UCharVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.UCharVector_pop_back(self)

	def erase(self, *args) -> "std::vector< unsigned char >::iterator":
	return _npstat.UCharVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_UCharVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'std::vector< unsigned char >::value_type const &') -> "void":
	return _npstat.UCharVector_push_back(self, x)

	def front(self) -> "std::vector< unsigned char >::value_type const &":
	return _npstat.UCharVector_front(self)

	def back(self) -> "std::vector< unsigned char >::value_type const &":
	return _npstat.UCharVector_back(self)

	def assign(self, n: 'std::vector< unsigned char >::size_type', x: 'std::vector< unsigned char >::value_type const &') -> "void":
	return _npstat.UCharVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.UCharVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.UCharVector_insert(self, *args)

	def reserve(self, n: 'std::vector< unsigned char >::size_type') -> "void":
	return _npstat.UCharVector_reserve(self, n)

	def capacity(self) -> "std::vector< unsigned char >::size_type":
	return _npstat.UCharVector_capacity(self)
	__swig_destroy__ = _npstat.delete_UCharVector
	__del__ = lambda self: None
	UCharVector_swigregister = _npstat.UCharVector_swigregister
	UCharVector_swigregister(UCharVector)

	class ShortVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, ShortVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, ShortVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.ShortVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.ShortVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.ShortVector___bool__(self)

	def __len__(self) -> "std::vector< short >::size_type":
	return _npstat.ShortVector___len__(self)

	def __getslice__(self, i: 'std::vector< short >::difference_type', j: 'std::vector< short >::difference_type') -> "std::vector< short,std::allocator< short > > *":
	return _npstat.ShortVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.ShortVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< short >::difference_type', j: 'std::vector< short >::difference_type') -> "void":
	return _npstat.ShortVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.ShortVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< short >::value_type const &":
	return _npstat.ShortVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.ShortVector___setitem__(self, *args)

	def pop(self) -> "std::vector< short >::value_type":
	return _npstat.ShortVector_pop(self)

	def append(self, x: 'std::vector< short >::value_type const &') -> "void":
	return _npstat.ShortVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.ShortVector_empty(self)

	def size(self) -> "std::vector< short >::size_type":
	return _npstat.ShortVector_size(self)

	def swap(self, v: 'ShortVector') -> "void":
	return _npstat.ShortVector_swap(self, v)

	def begin(self) -> "std::vector< short >::iterator":
	return _npstat.ShortVector_begin(self)

	def end(self) -> "std::vector< short >::iterator":
	return _npstat.ShortVector_end(self)

	def rbegin(self) -> "std::vector< short >::reverse_iterator":
	return _npstat.ShortVector_rbegin(self)

	def rend(self) -> "std::vector< short >::reverse_iterator":
	return _npstat.ShortVector_rend(self)

	def clear(self) -> "void":
	return _npstat.ShortVector_clear(self)

	def get_allocator(self) -> "std::vector< short >::allocator_type":
	return _npstat.ShortVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.ShortVector_pop_back(self)

	def erase(self, *args) -> "std::vector< short >::iterator":
	return _npstat.ShortVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_ShortVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'std::vector< short >::value_type const &') -> "void":
	return _npstat.ShortVector_push_back(self, x)

	def front(self) -> "std::vector< short >::value_type const &":
	return _npstat.ShortVector_front(self)

	def back(self) -> "std::vector< short >::value_type const &":
	return _npstat.ShortVector_back(self)

	def assign(self, n: 'std::vector< short >::size_type', x: 'std::vector< short >::value_type const &') -> "void":
	return _npstat.ShortVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.ShortVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.ShortVector_insert(self, *args)

	def reserve(self, n: 'std::vector< short >::size_type') -> "void":
	return _npstat.ShortVector_reserve(self, n)

	def capacity(self) -> "std::vector< short >::size_type":
	return _npstat.ShortVector_capacity(self)
	__swig_destroy__ = _npstat.delete_ShortVector
	__del__ = lambda self: None
	ShortVector_swigregister = _npstat.ShortVector_swigregister
	ShortVector_swigregister(ShortVector)

	class UShortVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UShortVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UShortVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.UShortVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.UShortVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.UShortVector___bool__(self)

	def __len__(self) -> "std::vector< unsigned short >::size_type":
	return _npstat.UShortVector___len__(self)

	def __getslice__(self, i: 'std::vector< unsigned short >::difference_type', j: 'std::vector< unsigned short >::difference_type') -> "std::vector< unsigned short,std::allocator< unsigned short > > *":
	return _npstat.UShortVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.UShortVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< unsigned short >::difference_type', j: 'std::vector< unsigned short >::difference_type') -> "void":
	return _npstat.UShortVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.UShortVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< unsigned short >::value_type const &":
	return _npstat.UShortVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.UShortVector___setitem__(self, *args)

	def pop(self) -> "std::vector< unsigned short >::value_type":
	return _npstat.UShortVector_pop(self)

	def append(self, x: 'std::vector< unsigned short >::value_type const &') -> "void":
	return _npstat.UShortVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.UShortVector_empty(self)

	def size(self) -> "std::vector< unsigned short >::size_type":
	return _npstat.UShortVector_size(self)

	def swap(self, v: 'UShortVector') -> "void":
	return _npstat.UShortVector_swap(self, v)

	def begin(self) -> "std::vector< unsigned short >::iterator":
	return _npstat.UShortVector_begin(self)

	def end(self) -> "std::vector< unsigned short >::iterator":
	return _npstat.UShortVector_end(self)

	def rbegin(self) -> "std::vector< unsigned short >::reverse_iterator":
	return _npstat.UShortVector_rbegin(self)

	def rend(self) -> "std::vector< unsigned short >::reverse_iterator":
	return _npstat.UShortVector_rend(self)

	def clear(self) -> "void":
	return _npstat.UShortVector_clear(self)

	def get_allocator(self) -> "std::vector< unsigned short >::allocator_type":
	return _npstat.UShortVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.UShortVector_pop_back(self)

	def erase(self, *args) -> "std::vector< unsigned short >::iterator":
	return _npstat.UShortVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_UShortVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'std::vector< unsigned short >::value_type const &') -> "void":
	return _npstat.UShortVector_push_back(self, x)

	def front(self) -> "std::vector< unsigned short >::value_type const &":
	return _npstat.UShortVector_front(self)

	def back(self) -> "std::vector< unsigned short >::value_type const &":
	return _npstat.UShortVector_back(self)

	def assign(self, n: 'std::vector< unsigned short >::size_type', x: 'std::vector< unsigned short >::value_type const &') -> "void":
	return _npstat.UShortVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.UShortVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.UShortVector_insert(self, *args)

	def reserve(self, n: 'std::vector< unsigned short >::size_type') -> "void":
	return _npstat.UShortVector_reserve(self, n)

	def capacity(self) -> "std::vector< unsigned short >::size_type":
	return _npstat.UShortVector_capacity(self)
	__swig_destroy__ = _npstat.delete_UShortVector
	__del__ = lambda self: None
	UShortVector_swigregister = _npstat.UShortVector_swigregister
	UShortVector_swigregister(UShortVector)

	class LongVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LongVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LongVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.LongVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.LongVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.LongVector___bool__(self)

	def __len__(self) -> "std::vector< long >::size_type":
	return _npstat.LongVector___len__(self)

	def __getslice__(self, i: 'std::vector< long >::difference_type', j: 'std::vector< long >::difference_type') -> "std::vector< long,std::allocator< long > > *":
	return _npstat.LongVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.LongVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< long >::difference_type', j: 'std::vector< long >::difference_type') -> "void":
	return _npstat.LongVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.LongVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< long >::value_type const &":
	return _npstat.LongVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.LongVector___setitem__(self, *args)

	def pop(self) -> "std::vector< long >::value_type":
	return _npstat.LongVector_pop(self)

	def append(self, x: 'std::vector< long >::value_type const &') -> "void":
	return _npstat.LongVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.LongVector_empty(self)

	def size(self) -> "std::vector< long >::size_type":
	return _npstat.LongVector_size(self)

	def swap(self, v: 'LongVector') -> "void":
	return _npstat.LongVector_swap(self, v)

	def begin(self) -> "std::vector< long >::iterator":
	return _npstat.LongVector_begin(self)

	def end(self) -> "std::vector< long >::iterator":
	return _npstat.LongVector_end(self)

	def rbegin(self) -> "std::vector< long >::reverse_iterator":
	return _npstat.LongVector_rbegin(self)

	def rend(self) -> "std::vector< long >::reverse_iterator":
	return _npstat.LongVector_rend(self)

	def clear(self) -> "void":
	return _npstat.LongVector_clear(self)

	def get_allocator(self) -> "std::vector< long >::allocator_type":
	return _npstat.LongVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.LongVector_pop_back(self)

	def erase(self, *args) -> "std::vector< long >::iterator":
	return _npstat.LongVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_LongVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'std::vector< long >::value_type const &') -> "void":
	return _npstat.LongVector_push_back(self, x)

	def front(self) -> "std::vector< long >::value_type const &":
	return _npstat.LongVector_front(self)

	def back(self) -> "std::vector< long >::value_type const &":
	return _npstat.LongVector_back(self)

	def assign(self, n: 'std::vector< long >::size_type', x: 'std::vector< long >::value_type const &') -> "void":
	return _npstat.LongVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.LongVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.LongVector_insert(self, *args)

	def reserve(self, n: 'std::vector< long >::size_type') -> "void":
	return _npstat.LongVector_reserve(self, n)

	def capacity(self) -> "std::vector< long >::size_type":
	return _npstat.LongVector_capacity(self)
	__swig_destroy__ = _npstat.delete_LongVector
	__del__ = lambda self: None
	LongVector_swigregister = _npstat.LongVector_swigregister
	LongVector_swigregister(LongVector)

	class ULongVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, ULongVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, ULongVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.ULongVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.ULongVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.ULongVector___bool__(self)

	def __len__(self) -> "std::vector< unsigned long >::size_type":
	return _npstat.ULongVector___len__(self)

	def __getslice__(self, i: 'std::vector< unsigned long >::difference_type', j: 'std::vector< unsigned long >::difference_type') -> "std::vector< unsigned long,std::allocator< unsigned long > > *":
	return _npstat.ULongVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.ULongVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< unsigned long >::difference_type', j: 'std::vector< unsigned long >::difference_type') -> "void":
	return _npstat.ULongVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.ULongVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< unsigned long >::value_type const &":
	return _npstat.ULongVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.ULongVector___setitem__(self, *args)

	def pop(self) -> "std::vector< unsigned long >::value_type":
	return _npstat.ULongVector_pop(self)

	def append(self, x: 'std::vector< unsigned long >::value_type const &') -> "void":
	return _npstat.ULongVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.ULongVector_empty(self)

	def size(self) -> "std::vector< unsigned long >::size_type":
	return _npstat.ULongVector_size(self)

	def swap(self, v: 'ULongVector') -> "void":
	return _npstat.ULongVector_swap(self, v)

	def begin(self) -> "std::vector< unsigned long >::iterator":
	return _npstat.ULongVector_begin(self)

	def end(self) -> "std::vector< unsigned long >::iterator":
	return _npstat.ULongVector_end(self)

	def rbegin(self) -> "std::vector< unsigned long >::reverse_iterator":
	return _npstat.ULongVector_rbegin(self)

	def rend(self) -> "std::vector< unsigned long >::reverse_iterator":
	return _npstat.ULongVector_rend(self)

	def clear(self) -> "void":
	return _npstat.ULongVector_clear(self)

	def get_allocator(self) -> "std::vector< unsigned long >::allocator_type":
	return _npstat.ULongVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.ULongVector_pop_back(self)

	def erase(self, *args) -> "std::vector< unsigned long >::iterator":
	return _npstat.ULongVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_ULongVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'std::vector< unsigned long >::value_type const &') -> "void":
	return _npstat.ULongVector_push_back(self, x)

	def front(self) -> "std::vector< unsigned long >::value_type const &":
	return _npstat.ULongVector_front(self)

	def back(self) -> "std::vector< unsigned long >::value_type const &":
	return _npstat.ULongVector_back(self)

	def assign(self, n: 'std::vector< unsigned long >::size_type', x: 'std::vector< unsigned long >::value_type const &') -> "void":
	return _npstat.ULongVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.ULongVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.ULongVector_insert(self, *args)

	def reserve(self, n: 'std::vector< unsigned long >::size_type') -> "void":
	return _npstat.ULongVector_reserve(self, n)

	def capacity(self) -> "std::vector< unsigned long >::size_type":
	return _npstat.ULongVector_capacity(self)
	__swig_destroy__ = _npstat.delete_ULongVector
	__del__ = lambda self: None
	ULongVector_swigregister = _npstat.ULongVector_swigregister
	ULongVector_swigregister(ULongVector)

	class IntVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.IntVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.IntVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.IntVector___bool__(self)

	def __len__(self) -> "std::vector< int >::size_type":
	return _npstat.IntVector___len__(self)

	def __getslice__(self, i: 'std::vector< int >::difference_type', j: 'std::vector< int >::difference_type') -> "std::vector< int,std::allocator< int > > *":
	return _npstat.IntVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.IntVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< int >::difference_type', j: 'std::vector< int >::difference_type') -> "void":
	return _npstat.IntVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.IntVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< int >::value_type const &":
	return _npstat.IntVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.IntVector___setitem__(self, *args)

	def pop(self) -> "std::vector< int >::value_type":
	return _npstat.IntVector_pop(self)

	def append(self, x: 'std::vector< int >::value_type const &') -> "void":
	return _npstat.IntVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.IntVector_empty(self)

	def size(self) -> "std::vector< int >::size_type":
	return _npstat.IntVector_size(self)

	def swap(self, v: 'IntVector') -> "void":
	return _npstat.IntVector_swap(self, v)

	def begin(self) -> "std::vector< int >::iterator":
	return _npstat.IntVector_begin(self)

	def end(self) -> "std::vector< int >::iterator":
	return _npstat.IntVector_end(self)

	def rbegin(self) -> "std::vector< int >::reverse_iterator":
	return _npstat.IntVector_rbegin(self)

	def rend(self) -> "std::vector< int >::reverse_iterator":
	return _npstat.IntVector_rend(self)

	def clear(self) -> "void":
	return _npstat.IntVector_clear(self)

	def get_allocator(self) -> "std::vector< int >::allocator_type":
	return _npstat.IntVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.IntVector_pop_back(self)

	def erase(self, *args) -> "std::vector< int >::iterator":
	return _npstat.IntVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_IntVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'std::vector< int >::value_type const &') -> "void":
	return _npstat.IntVector_push_back(self, x)

	def front(self) -> "std::vector< int >::value_type const &":
	return _npstat.IntVector_front(self)

	def back(self) -> "std::vector< int >::value_type const &":
	return _npstat.IntVector_back(self)

	def assign(self, n: 'std::vector< int >::size_type', x: 'std::vector< int >::value_type const &') -> "void":
	return _npstat.IntVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.IntVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.IntVector_insert(self, *args)

	def reserve(self, n: 'std::vector< int >::size_type') -> "void":
	return _npstat.IntVector_reserve(self, n)

	def capacity(self) -> "std::vector< int >::size_type":
	return _npstat.IntVector_capacity(self)
	__swig_destroy__ = _npstat.delete_IntVector
	__del__ = lambda self: None
	IntVector_swigregister = _npstat.IntVector_swigregister
	IntVector_swigregister(IntVector)

	class LLongVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.LLongVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.LLongVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.LLongVector___bool__(self)

	def __len__(self) -> "std::vector< long long >::size_type":
	return _npstat.LLongVector___len__(self)

	def __getslice__(self, i: 'std::vector< long long >::difference_type', j: 'std::vector< long long >::difference_type') -> "std::vector< long long,std::allocator< long long > > *":
	return _npstat.LLongVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.LLongVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< long long >::difference_type', j: 'std::vector< long long >::difference_type') -> "void":
	return _npstat.LLongVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.LLongVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< long long >::value_type const &":
	return _npstat.LLongVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.LLongVector___setitem__(self, *args)

	def pop(self) -> "std::vector< long long >::value_type":
	return _npstat.LLongVector_pop(self)

	def append(self, x: 'std::vector< long long >::value_type const &') -> "void":
	return _npstat.LLongVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.LLongVector_empty(self)

	def size(self) -> "std::vector< long long >::size_type":
	return _npstat.LLongVector_size(self)

	def swap(self, v: 'LLongVector') -> "void":
	return _npstat.LLongVector_swap(self, v)

	def begin(self) -> "std::vector< long long >::iterator":
	return _npstat.LLongVector_begin(self)

	def end(self) -> "std::vector< long long >::iterator":
	return _npstat.LLongVector_end(self)

	def rbegin(self) -> "std::vector< long long >::reverse_iterator":
	return _npstat.LLongVector_rbegin(self)

	def rend(self) -> "std::vector< long long >::reverse_iterator":
	return _npstat.LLongVector_rend(self)

	def clear(self) -> "void":
	return _npstat.LLongVector_clear(self)

	def get_allocator(self) -> "std::vector< long long >::allocator_type":
	return _npstat.LLongVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.LLongVector_pop_back(self)

	def erase(self, *args) -> "std::vector< long long >::iterator":
	return _npstat.LLongVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_LLongVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'std::vector< long long >::value_type const &') -> "void":
	return _npstat.LLongVector_push_back(self, x)

	def front(self) -> "std::vector< long long >::value_type const &":
	return _npstat.LLongVector_front(self)

	def back(self) -> "std::vector< long long >::value_type const &":
	return _npstat.LLongVector_back(self)

	def assign(self, n: 'std::vector< long long >::size_type', x: 'std::vector< long long >::value_type const &') -> "void":
	return _npstat.LLongVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.LLongVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.LLongVector_insert(self, *args)

	def reserve(self, n: 'std::vector< long long >::size_type') -> "void":
	return _npstat.LLongVector_reserve(self, n)

	def capacity(self) -> "std::vector< long long >::size_type":
	return _npstat.LLongVector_capacity(self)
	__swig_destroy__ = _npstat.delete_LLongVector
	__del__ = lambda self: None
	LLongVector_swigregister = _npstat.LLongVector_swigregister
	LLongVector_swigregister(LLongVector)

	class UIntVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UIntVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UIntVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.UIntVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.UIntVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.UIntVector___bool__(self)

	def __len__(self) -> "std::vector< unsigned int >::size_type":
	return _npstat.UIntVector___len__(self)

	def __getslice__(self, i: 'std::vector< unsigned int >::difference_type', j: 'std::vector< unsigned int >::difference_type') -> "std::vector< unsigned int,std::allocator< unsigned int > > *":
	return _npstat.UIntVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.UIntVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< unsigned int >::difference_type', j: 'std::vector< unsigned int >::difference_type') -> "void":
	return _npstat.UIntVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.UIntVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< unsigned int >::value_type const &":
	return _npstat.UIntVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.UIntVector___setitem__(self, *args)

	def pop(self) -> "std::vector< unsigned int >::value_type":
	return _npstat.UIntVector_pop(self)

	def append(self, x: 'std::vector< unsigned int >::value_type const &') -> "void":
	return _npstat.UIntVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.UIntVector_empty(self)

	def size(self) -> "std::vector< unsigned int >::size_type":
	return _npstat.UIntVector_size(self)

	def swap(self, v: 'UIntVector') -> "void":
	return _npstat.UIntVector_swap(self, v)

	def begin(self) -> "std::vector< unsigned int >::iterator":
	return _npstat.UIntVector_begin(self)

	def end(self) -> "std::vector< unsigned int >::iterator":
	return _npstat.UIntVector_end(self)

	def rbegin(self) -> "std::vector< unsigned int >::reverse_iterator":
	return _npstat.UIntVector_rbegin(self)

	def rend(self) -> "std::vector< unsigned int >::reverse_iterator":
	return _npstat.UIntVector_rend(self)

	def clear(self) -> "void":
	return _npstat.UIntVector_clear(self)

	def get_allocator(self) -> "std::vector< unsigned int >::allocator_type":
	return _npstat.UIntVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.UIntVector_pop_back(self)

	def erase(self, *args) -> "std::vector< unsigned int >::iterator":
	return _npstat.UIntVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_UIntVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'std::vector< unsigned int >::value_type const &') -> "void":
	return _npstat.UIntVector_push_back(self, x)

	def front(self) -> "std::vector< unsigned int >::value_type const &":
	return _npstat.UIntVector_front(self)

	def back(self) -> "std::vector< unsigned int >::value_type const &":
	return _npstat.UIntVector_back(self)

	def assign(self, n: 'std::vector< unsigned int >::size_type', x: 'std::vector< unsigned int >::value_type const &') -> "void":
	return _npstat.UIntVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.UIntVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.UIntVector_insert(self, *args)

	def reserve(self, n: 'std::vector< unsigned int >::size_type') -> "void":
	return _npstat.UIntVector_reserve(self, n)

	def capacity(self) -> "std::vector< unsigned int >::size_type":
	return _npstat.UIntVector_capacity(self)
	__swig_destroy__ = _npstat.delete_UIntVector
	__del__ = lambda self: None
	UIntVector_swigregister = _npstat.UIntVector_swigregister
	UIntVector_swigregister(UIntVector)

	class ULLongVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, ULLongVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, ULLongVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.ULLongVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.ULLongVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.ULLongVector___bool__(self)

	def __len__(self) -> "std::vector< unsigned long long >::size_type":
	return _npstat.ULLongVector___len__(self)

	def __getslice__(self, i: 'std::vector< unsigned long long >::difference_type', j: 'std::vector< unsigned long long >::difference_type') -> "std::vector< unsigned long long,std::allocator< unsigned long long > > *":
	return _npstat.ULLongVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.ULLongVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< unsigned long long >::difference_type', j: 'std::vector< unsigned long long >::difference_type') -> "void":
	return _npstat.ULLongVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.ULLongVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< unsigned long long >::value_type const &":
	return _npstat.ULLongVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.ULLongVector___setitem__(self, *args)

	def pop(self) -> "std::vector< unsigned long long >::value_type":
	return _npstat.ULLongVector_pop(self)

	def append(self, x: 'std::vector< unsigned long long >::value_type const &') -> "void":
	return _npstat.ULLongVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.ULLongVector_empty(self)

	def size(self) -> "std::vector< unsigned long long >::size_type":
	return _npstat.ULLongVector_size(self)

	def swap(self, v: 'ULLongVector') -> "void":
	return _npstat.ULLongVector_swap(self, v)

	def begin(self) -> "std::vector< unsigned long long >::iterator":
	return _npstat.ULLongVector_begin(self)

	def end(self) -> "std::vector< unsigned long long >::iterator":
	return _npstat.ULLongVector_end(self)

	def rbegin(self) -> "std::vector< unsigned long long >::reverse_iterator":
	return _npstat.ULLongVector_rbegin(self)

	def rend(self) -> "std::vector< unsigned long long >::reverse_iterator":
	return _npstat.ULLongVector_rend(self)

	def clear(self) -> "void":
	return _npstat.ULLongVector_clear(self)

	def get_allocator(self) -> "std::vector< unsigned long long >::allocator_type":
	return _npstat.ULLongVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.ULLongVector_pop_back(self)

	def erase(self, *args) -> "std::vector< unsigned long long >::iterator":
	return _npstat.ULLongVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_ULLongVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'std::vector< unsigned long long >::value_type const &') -> "void":
	return _npstat.ULLongVector_push_back(self, x)

	def front(self) -> "std::vector< unsigned long long >::value_type const &":
	return _npstat.ULLongVector_front(self)

	def back(self) -> "std::vector< unsigned long long >::value_type const &":
	return _npstat.ULLongVector_back(self)

	def assign(self, n: 'std::vector< unsigned long long >::size_type', x: 'std::vector< unsigned long long >::value_type const &') -> "void":
	return _npstat.ULLongVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.ULLongVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.ULLongVector_insert(self, *args)

	def reserve(self, n: 'std::vector< unsigned long long >::size_type') -> "void":
	return _npstat.ULLongVector_reserve(self, n)

	def capacity(self) -> "std::vector< unsigned long long >::size_type":
	return _npstat.ULLongVector_capacity(self)
	__swig_destroy__ = _npstat.delete_ULLongVector
	__del__ = lambda self: None
	ULLongVector_swigregister = _npstat.ULLongVector_swigregister
	ULLongVector_swigregister(ULLongVector)

	class FloatVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.FloatVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.FloatVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.FloatVector___bool__(self)

	def __len__(self) -> "std::vector< float >::size_type":
	return _npstat.FloatVector___len__(self)

	def __getslice__(self, i: 'std::vector< float >::difference_type', j: 'std::vector< float >::difference_type') -> "std::vector< float,std::allocator< float > > *":
	return _npstat.FloatVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.FloatVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< float >::difference_type', j: 'std::vector< float >::difference_type') -> "void":
	return _npstat.FloatVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.FloatVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< float >::value_type const &":
	return _npstat.FloatVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.FloatVector___setitem__(self, *args)

	def pop(self) -> "std::vector< float >::value_type":
	return _npstat.FloatVector_pop(self)

	def append(self, x: 'std::vector< float >::value_type const &') -> "void":
	return _npstat.FloatVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.FloatVector_empty(self)

	def size(self) -> "std::vector< float >::size_type":
	return _npstat.FloatVector_size(self)

	def swap(self, v: 'FloatVector') -> "void":
	return _npstat.FloatVector_swap(self, v)

	def begin(self) -> "std::vector< float >::iterator":
	return _npstat.FloatVector_begin(self)

	def end(self) -> "std::vector< float >::iterator":
	return _npstat.FloatVector_end(self)

	def rbegin(self) -> "std::vector< float >::reverse_iterator":
	return _npstat.FloatVector_rbegin(self)

	def rend(self) -> "std::vector< float >::reverse_iterator":
	return _npstat.FloatVector_rend(self)

	def clear(self) -> "void":
	return _npstat.FloatVector_clear(self)

	def get_allocator(self) -> "std::vector< float >::allocator_type":
	return _npstat.FloatVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.FloatVector_pop_back(self)

	def erase(self, *args) -> "std::vector< float >::iterator":
	return _npstat.FloatVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_FloatVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'std::vector< float >::value_type const &') -> "void":
	return _npstat.FloatVector_push_back(self, x)

	def front(self) -> "std::vector< float >::value_type const &":
	return _npstat.FloatVector_front(self)

	def back(self) -> "std::vector< float >::value_type const &":
	return _npstat.FloatVector_back(self)

	def assign(self, n: 'std::vector< float >::size_type', x: 'std::vector< float >::value_type const &') -> "void":
	return _npstat.FloatVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.FloatVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.FloatVector_insert(self, *args)

	def reserve(self, n: 'std::vector< float >::size_type') -> "void":
	return _npstat.FloatVector_reserve(self, n)

	def capacity(self) -> "std::vector< float >::size_type":
	return _npstat.FloatVector_capacity(self)
	__swig_destroy__ = _npstat.delete_FloatVector
	__del__ = lambda self: None
	FloatVector_swigregister = _npstat.FloatVector_swigregister
	FloatVector_swigregister(FloatVector)

	class DoubleVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.DoubleVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.DoubleVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.DoubleVector___bool__(self)

	def __len__(self) -> "std::vector< double >::size_type":
	return _npstat.DoubleVector___len__(self)

	def __getslice__(self, i: 'std::vector< double >::difference_type', j: 'std::vector< double >::difference_type') -> "std::vector< double,std::allocator< double > > *":
	return _npstat.DoubleVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.DoubleVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< double >::difference_type', j: 'std::vector< double >::difference_type') -> "void":
	return _npstat.DoubleVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.DoubleVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< double >::value_type const &":
	return _npstat.DoubleVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.DoubleVector___setitem__(self, *args)

	def pop(self) -> "std::vector< double >::value_type":
	return _npstat.DoubleVector_pop(self)

	def append(self, x: 'std::vector< double >::value_type const &') -> "void":
	return _npstat.DoubleVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.DoubleVector_empty(self)

	def size(self) -> "std::vector< double >::size_type":
	return _npstat.DoubleVector_size(self)

	def swap(self, v: 'DoubleVector') -> "void":
	return _npstat.DoubleVector_swap(self, v)

	def begin(self) -> "std::vector< double >::iterator":
	return _npstat.DoubleVector_begin(self)

	def end(self) -> "std::vector< double >::iterator":
	return _npstat.DoubleVector_end(self)

	def rbegin(self) -> "std::vector< double >::reverse_iterator":
	return _npstat.DoubleVector_rbegin(self)

	def rend(self) -> "std::vector< double >::reverse_iterator":
	return _npstat.DoubleVector_rend(self)

	def clear(self) -> "void":
	return _npstat.DoubleVector_clear(self)

	def get_allocator(self) -> "std::vector< double >::allocator_type":
	return _npstat.DoubleVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.DoubleVector_pop_back(self)

	def erase(self, *args) -> "std::vector< double >::iterator":
	return _npstat.DoubleVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_DoubleVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'std::vector< double >::value_type const &') -> "void":
	return _npstat.DoubleVector_push_back(self, x)

	def front(self) -> "std::vector< double >::value_type const &":
	return _npstat.DoubleVector_front(self)

	def back(self) -> "std::vector< double >::value_type const &":
	return _npstat.DoubleVector_back(self)

	def assign(self, n: 'std::vector< double >::size_type', x: 'std::vector< double >::value_type const &') -> "void":
	return _npstat.DoubleVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.DoubleVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.DoubleVector_insert(self, *args)

	def reserve(self, n: 'std::vector< double >::size_type') -> "void":
	return _npstat.DoubleVector_reserve(self, n)

	def capacity(self) -> "std::vector< double >::size_type":
	return _npstat.DoubleVector_capacity(self)
	__swig_destroy__ = _npstat.delete_DoubleVector
	__del__ = lambda self: None
	DoubleVector_swigregister = _npstat.DoubleVector_swigregister
	DoubleVector_swigregister(DoubleVector)

	class LDoubleVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LDoubleVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LDoubleVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.LDoubleVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.LDoubleVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.LDoubleVector___bool__(self)

	def __len__(self) -> "std::vector< long double >::size_type":
	return _npstat.LDoubleVector___len__(self)

	def __getslice__(self, i: 'std::vector< long double >::difference_type', j: 'std::vector< long double >::difference_type') -> "std::vector< long double,std::allocator< long double > > *":
	return _npstat.LDoubleVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.LDoubleVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< long double >::difference_type', j: 'std::vector< long double >::difference_type') -> "void":
	return _npstat.LDoubleVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.LDoubleVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< long double >::value_type const &":
	return _npstat.LDoubleVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.LDoubleVector___setitem__(self, *args)

	def pop(self) -> "std::vector< long double >::value_type":
	return _npstat.LDoubleVector_pop(self)

	def append(self, x: 'std::vector< long double >::value_type const &') -> "void":
	return _npstat.LDoubleVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.LDoubleVector_empty(self)

	def size(self) -> "std::vector< long double >::size_type":
	return _npstat.LDoubleVector_size(self)

	def swap(self, v: 'LDoubleVector') -> "void":
	return _npstat.LDoubleVector_swap(self, v)

	def begin(self) -> "std::vector< long double >::iterator":
	return _npstat.LDoubleVector_begin(self)

	def end(self) -> "std::vector< long double >::iterator":
	return _npstat.LDoubleVector_end(self)

	def rbegin(self) -> "std::vector< long double >::reverse_iterator":
	return _npstat.LDoubleVector_rbegin(self)

	def rend(self) -> "std::vector< long double >::reverse_iterator":
	return _npstat.LDoubleVector_rend(self)

	def clear(self) -> "void":
	return _npstat.LDoubleVector_clear(self)

	def get_allocator(self) -> "std::vector< long double >::allocator_type":
	return _npstat.LDoubleVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.LDoubleVector_pop_back(self)

	def erase(self, *args) -> "std::vector< long double >::iterator":
	return _npstat.LDoubleVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_LDoubleVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'std::vector< long double >::value_type const &') -> "void":
	return _npstat.LDoubleVector_push_back(self, x)

	def front(self) -> "std::vector< long double >::value_type const &":
	return _npstat.LDoubleVector_front(self)

	def back(self) -> "std::vector< long double >::value_type const &":
	return _npstat.LDoubleVector_back(self)

	def assign(self, n: 'std::vector< long double >::size_type', x: 'std::vector< long double >::value_type const &') -> "void":
	return _npstat.LDoubleVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.LDoubleVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.LDoubleVector_insert(self, *args)

	def reserve(self, n: 'std::vector< long double >::size_type') -> "void":
	return _npstat.LDoubleVector_reserve(self, n)

	def capacity(self) -> "std::vector< long double >::size_type":
	return _npstat.LDoubleVector_capacity(self)
	__swig_destroy__ = _npstat.delete_LDoubleVector
	__del__ = lambda self: None
	LDoubleVector_swigregister = _npstat.LDoubleVector_swigregister
	LDoubleVector_swigregister(LDoubleVector)

	class CFloatVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, CFloatVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, CFloatVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.CFloatVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.CFloatVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.CFloatVector___bool__(self)

	def __len__(self) -> "std::vector< std::complex< float > >::size_type":
	return _npstat.CFloatVector___len__(self)

	def __getslice__(self, i: 'std::vector< std::complex< float > >::difference_type', j: 'std::vector< std::complex< float > >::difference_type') -> "std::vector< std::complex< float >,std::allocator< std::complex< float > > > *":
	return _npstat.CFloatVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.CFloatVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< std::complex< float > >::difference_type', j: 'std::vector< std::complex< float > >::difference_type') -> "void":
	return _npstat.CFloatVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.CFloatVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< std::complex< float > >::value_type const &":
	return _npstat.CFloatVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.CFloatVector___setitem__(self, *args)

	def pop(self) -> "std::vector< std::complex< float > >::value_type":
	return _npstat.CFloatVector_pop(self)

	def append(self, x: 'std::vector< std::complex< float > >::value_type const &') -> "void":
	return _npstat.CFloatVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.CFloatVector_empty(self)

	def size(self) -> "std::vector< std::complex< float > >::size_type":
	return _npstat.CFloatVector_size(self)

	def swap(self, v: 'CFloatVector') -> "void":
	return _npstat.CFloatVector_swap(self, v)

	def begin(self) -> "std::vector< std::complex< float > >::iterator":
	return _npstat.CFloatVector_begin(self)

	def end(self) -> "std::vector< std::complex< float > >::iterator":
	return _npstat.CFloatVector_end(self)

	def rbegin(self) -> "std::vector< std::complex< float > >::reverse_iterator":
	return _npstat.CFloatVector_rbegin(self)

	def rend(self) -> "std::vector< std::complex< float > >::reverse_iterator":
	return _npstat.CFloatVector_rend(self)

	def clear(self) -> "void":
	return _npstat.CFloatVector_clear(self)

	def get_allocator(self) -> "std::vector< std::complex< float > >::allocator_type":
	return _npstat.CFloatVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.CFloatVector_pop_back(self)

	def erase(self, *args) -> "std::vector< std::complex< float > >::iterator":
	return _npstat.CFloatVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_CFloatVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'std::vector< std::complex< float > >::value_type const &') -> "void":
	return _npstat.CFloatVector_push_back(self, x)

	def front(self) -> "std::vector< std::complex< float > >::value_type const &":
	return _npstat.CFloatVector_front(self)

	def back(self) -> "std::vector< std::complex< float > >::value_type const &":
	return _npstat.CFloatVector_back(self)

	def assign(self, n: 'std::vector< std::complex< float > >::size_type', x: 'std::vector< std::complex< float > >::value_type const &') -> "void":
	return _npstat.CFloatVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.CFloatVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.CFloatVector_insert(self, *args)

	def reserve(self, n: 'std::vector< std::complex< float > >::size_type') -> "void":
	return _npstat.CFloatVector_reserve(self, n)

	def capacity(self) -> "std::vector< std::complex< float > >::size_type":
	return _npstat.CFloatVector_capacity(self)
	__swig_destroy__ = _npstat.delete_CFloatVector
	__del__ = lambda self: None
	CFloatVector_swigregister = _npstat.CFloatVector_swigregister
	CFloatVector_swigregister(CFloatVector)

	class CDoubleVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, CDoubleVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, CDoubleVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.CDoubleVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.CDoubleVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.CDoubleVector___bool__(self)

	def __len__(self) -> "std::vector< std::complex< double > >::size_type":
	return _npstat.CDoubleVector___len__(self)

	def __getslice__(self, i: 'std::vector< std::complex< double > >::difference_type', j: 'std::vector< std::complex< double > >::difference_type') -> "std::vector< std::complex< double >,std::allocator< std::complex< double > > > *":
	return _npstat.CDoubleVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.CDoubleVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< std::complex< double > >::difference_type', j: 'std::vector< std::complex< double > >::difference_type') -> "void":
	return _npstat.CDoubleVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.CDoubleVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< std::complex< double > >::value_type const &":
	return _npstat.CDoubleVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.CDoubleVector___setitem__(self, *args)

	def pop(self) -> "std::vector< std::complex< double > >::value_type":
	return _npstat.CDoubleVector_pop(self)

	def append(self, x: 'std::vector< std::complex< double > >::value_type const &') -> "void":
	return _npstat.CDoubleVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.CDoubleVector_empty(self)

	def size(self) -> "std::vector< std::complex< double > >::size_type":
	return _npstat.CDoubleVector_size(self)

	def swap(self, v: 'CDoubleVector') -> "void":
	return _npstat.CDoubleVector_swap(self, v)

	def begin(self) -> "std::vector< std::complex< double > >::iterator":
	return _npstat.CDoubleVector_begin(self)

	def end(self) -> "std::vector< std::complex< double > >::iterator":
	return _npstat.CDoubleVector_end(self)

	def rbegin(self) -> "std::vector< std::complex< double > >::reverse_iterator":
	return _npstat.CDoubleVector_rbegin(self)

	def rend(self) -> "std::vector< std::complex< double > >::reverse_iterator":
	return _npstat.CDoubleVector_rend(self)

	def clear(self) -> "void":
	return _npstat.CDoubleVector_clear(self)

	def get_allocator(self) -> "std::vector< std::complex< double > >::allocator_type":
	return _npstat.CDoubleVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.CDoubleVector_pop_back(self)

	def erase(self, *args) -> "std::vector< std::complex< double > >::iterator":
	return _npstat.CDoubleVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_CDoubleVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'std::vector< std::complex< double > >::value_type const &') -> "void":
	return _npstat.CDoubleVector_push_back(self, x)

	def front(self) -> "std::vector< std::complex< double > >::value_type const &":
	return _npstat.CDoubleVector_front(self)

	def back(self) -> "std::vector< std::complex< double > >::value_type const &":
	return _npstat.CDoubleVector_back(self)

	def assign(self, n: 'std::vector< std::complex< double > >::size_type', x: 'std::vector< std::complex< double > >::value_type const &') -> "void":
	return _npstat.CDoubleVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.CDoubleVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.CDoubleVector_insert(self, *args)

	def reserve(self, n: 'std::vector< std::complex< double > >::size_type') -> "void":
	return _npstat.CDoubleVector_reserve(self, n)

	def capacity(self) -> "std::vector< std::complex< double > >::size_type":
	return _npstat.CDoubleVector_capacity(self)
	__swig_destroy__ = _npstat.delete_CDoubleVector
	__del__ = lambda self: None
	CDoubleVector_swigregister = _npstat.CDoubleVector_swigregister
	CDoubleVector_swigregister(CDoubleVector)

	class CLDoubleVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, CLDoubleVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, CLDoubleVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.CLDoubleVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.CLDoubleVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.CLDoubleVector___bool__(self)

	def __len__(self) -> "std::vector< std::complex< long double > >::size_type":
	return _npstat.CLDoubleVector___len__(self)

	def __getslice__(self, i: 'std::vector< std::complex< long double > >::difference_type', j: 'std::vector< std::complex< long double > >::difference_type') -> "std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > *":
	return _npstat.CLDoubleVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.CLDoubleVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< std::complex< long double > >::difference_type', j: 'std::vector< std::complex< long double > >::difference_type') -> "void":
	return _npstat.CLDoubleVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.CLDoubleVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< std::complex< long double > >::value_type const &":
	return _npstat.CLDoubleVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.CLDoubleVector___setitem__(self, *args)

	def pop(self) -> "std::vector< std::complex< long double > >::value_type":
	return _npstat.CLDoubleVector_pop(self)

	def append(self, x: 'std::vector< std::complex< long double > >::value_type const &') -> "void":
	return _npstat.CLDoubleVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.CLDoubleVector_empty(self)

	def size(self) -> "std::vector< std::complex< long double > >::size_type":
	return _npstat.CLDoubleVector_size(self)

	def swap(self, v: 'CLDoubleVector') -> "void":
	return _npstat.CLDoubleVector_swap(self, v)

	def begin(self) -> "std::vector< std::complex< long double > >::iterator":
	return _npstat.CLDoubleVector_begin(self)

	def end(self) -> "std::vector< std::complex< long double > >::iterator":
	return _npstat.CLDoubleVector_end(self)

	def rbegin(self) -> "std::vector< std::complex< long double > >::reverse_iterator":
	return _npstat.CLDoubleVector_rbegin(self)

	def rend(self) -> "std::vector< std::complex< long double > >::reverse_iterator":
	return _npstat.CLDoubleVector_rend(self)

	def clear(self) -> "void":
	return _npstat.CLDoubleVector_clear(self)

	def get_allocator(self) -> "std::vector< std::complex< long double > >::allocator_type":
	return _npstat.CLDoubleVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.CLDoubleVector_pop_back(self)

	def erase(self, *args) -> "std::vector< std::complex< long double > >::iterator":
	return _npstat.CLDoubleVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_CLDoubleVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'std::vector< std::complex< long double > >::value_type const &') -> "void":
	return _npstat.CLDoubleVector_push_back(self, x)

	def front(self) -> "std::vector< std::complex< long double > >::value_type const &":
	return _npstat.CLDoubleVector_front(self)

	def back(self) -> "std::vector< std::complex< long double > >::value_type const &":
	return _npstat.CLDoubleVector_back(self)

	def assign(self, n: 'std::vector< std::complex< long double > >::size_type', x: 'std::vector< std::complex< long double > >::value_type const &') -> "void":
	return _npstat.CLDoubleVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.CLDoubleVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.CLDoubleVector_insert(self, *args)

	def reserve(self, n: 'std::vector< std::complex< long double > >::size_type') -> "void":
	return _npstat.CLDoubleVector_reserve(self, n)

	def capacity(self) -> "std::vector< std::complex< long double > >::size_type":
	return _npstat.CLDoubleVector_capacity(self)
	__swig_destroy__ = _npstat.delete_CLDoubleVector
	__del__ = lambda self: None
	CLDoubleVector_swigregister = _npstat.CLDoubleVector_swigregister
	CLDoubleVector_swigregister(CLDoubleVector)

	class StringVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.StringVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.StringVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.StringVector___bool__(self)

	def __len__(self) -> "std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::size_type":
	return _npstat.StringVector___len__(self)

	def __getslice__(self, i: 'std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::difference_type', j: 'std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::difference_type') -> "std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,std::allocator< std::basic_string< char,std::char_traits< char >,std::allocator< char > > > > *":
	return _npstat.StringVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.StringVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::difference_type', j: 'std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::difference_type') -> "void":
	return _npstat.StringVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.StringVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::value_type const &":
	return _npstat.StringVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.StringVector___setitem__(self, *args)

	def pop(self) -> "std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::value_type":
	return _npstat.StringVector_pop(self)

	def append(self, x: 'string') -> "void":
	return _npstat.StringVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.StringVector_empty(self)

	def size(self) -> "std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::size_type":
	return _npstat.StringVector_size(self)

	def swap(self, v: 'StringVector') -> "void":
	return _npstat.StringVector_swap(self, v)

	def begin(self) -> "std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::iterator":
	return _npstat.StringVector_begin(self)

	def end(self) -> "std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::iterator":
	return _npstat.StringVector_end(self)

	def rbegin(self) -> "std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::reverse_iterator":
	return _npstat.StringVector_rbegin(self)

	def rend(self) -> "std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::reverse_iterator":
	return _npstat.StringVector_rend(self)

	def clear(self) -> "void":
	return _npstat.StringVector_clear(self)

	def get_allocator(self) -> "std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::allocator_type":
	return _npstat.StringVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.StringVector_pop_back(self)

	def erase(self, *args) -> "std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::iterator":
	return _npstat.StringVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_StringVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'string') -> "void":
	return _npstat.StringVector_push_back(self, x)

	def front(self) -> "std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::value_type const &":
	return _npstat.StringVector_front(self)

	def back(self) -> "std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::value_type const &":
	return _npstat.StringVector_back(self)

	def assign(self, n: 'std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::size_type', x: 'string') -> "void":
	return _npstat.StringVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.StringVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.StringVector_insert(self, *args)

	def reserve(self, n: 'std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::size_type') -> "void":
	return _npstat.StringVector_reserve(self, n)

	def capacity(self) -> "std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >::size_type":
	return _npstat.StringVector_capacity(self)
	__swig_destroy__ = _npstat.delete_StringVector
	__del__ = lambda self: None
	StringVector_swigregister = _npstat.StringVector_swigregister
	StringVector_swigregister(StringVector)

	class IntDoublePair(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntDoublePair, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntDoublePair, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_IntDoublePair(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_setmethods__["first"] = _npstat.IntDoublePair_first_set
	__swig_getmethods__["first"] = _npstat.IntDoublePair_first_get
	if _newclass:
	first = _swig_property(_npstat.IntDoublePair_first_get, _npstat.IntDoublePair_first_set)
	__swig_setmethods__["second"] = _npstat.IntDoublePair_second_set
	__swig_getmethods__["second"] = _npstat.IntDoublePair_second_get
	if _newclass:
	second = _swig_property(_npstat.IntDoublePair_second_get, _npstat.IntDoublePair_second_set)
	def __len__(self):
	return 2
	def __repr__(self):
	return str((self.first, self.second))
	def __getitem__(self, index):
	if not (index % 2):
	return self.first
	else:
	return self.second
	def __setitem__(self, index, val):
	if not (index % 2):
	self.first = val
	else:
	self.second = val
	__swig_destroy__ = _npstat.delete_IntDoublePair
	__del__ = lambda self: None
	IntDoublePair_swigregister = _npstat.IntDoublePair_swigregister
	IntDoublePair_swigregister(IntDoublePair)

	class LLongDoublePair(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongDoublePair, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongDoublePair, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_LLongDoublePair(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_setmethods__["first"] = _npstat.LLongDoublePair_first_set
	__swig_getmethods__["first"] = _npstat.LLongDoublePair_first_get
	if _newclass:
	first = _swig_property(_npstat.LLongDoublePair_first_get, _npstat.LLongDoublePair_first_set)
	__swig_setmethods__["second"] = _npstat.LLongDoublePair_second_set
	__swig_getmethods__["second"] = _npstat.LLongDoublePair_second_get
	if _newclass:
	second = _swig_property(_npstat.LLongDoublePair_second_get, _npstat.LLongDoublePair_second_set)
	def __len__(self):
	return 2
	def __repr__(self):
	return str((self.first, self.second))
	def __getitem__(self, index):
	if not (index % 2):
	return self.first
	else:
	return self.second
	def __setitem__(self, index, val):
	if not (index % 2):
	self.first = val
	else:
	self.second = val
	__swig_destroy__ = _npstat.delete_LLongDoublePair
	__del__ = lambda self: None
	LLongDoublePair_swigregister = _npstat.LLongDoublePair_swigregister
	LLongDoublePair_swigregister(LLongDoublePair)

	class DoubleDoublePair(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleDoublePair, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleDoublePair, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_DoubleDoublePair(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_setmethods__["first"] = _npstat.DoubleDoublePair_first_set
	__swig_getmethods__["first"] = _npstat.DoubleDoublePair_first_get
	if _newclass:
	first = _swig_property(_npstat.DoubleDoublePair_first_get, _npstat.DoubleDoublePair_first_set)
	__swig_setmethods__["second"] = _npstat.DoubleDoublePair_second_set
	__swig_getmethods__["second"] = _npstat.DoubleDoublePair_second_get
	if _newclass:
	second = _swig_property(_npstat.DoubleDoublePair_second_get, _npstat.DoubleDoublePair_second_set)
	def __len__(self):
	return 2
	def __repr__(self):
	return str((self.first, self.second))
	def __getitem__(self, index):
	if not (index % 2):
	return self.first
	else:
	return self.second
	def __setitem__(self, index, val):
	if not (index % 2):
	self.first = val
	else:
	self.second = val
	__swig_destroy__ = _npstat.delete_DoubleDoublePair
	__del__ = lambda self: None
	DoubleDoublePair_swigregister = _npstat.DoubleDoublePair_swigregister
	DoubleDoublePair_swigregister(DoubleDoublePair)

	class LDoubleLDoublePair(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LDoubleLDoublePair, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LDoubleLDoublePair, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_LDoubleLDoublePair(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_setmethods__["first"] = _npstat.LDoubleLDoublePair_first_set
	__swig_getmethods__["first"] = _npstat.LDoubleLDoublePair_first_get
	if _newclass:
	first = _swig_property(_npstat.LDoubleLDoublePair_first_get, _npstat.LDoubleLDoublePair_first_set)
	__swig_setmethods__["second"] = _npstat.LDoubleLDoublePair_second_set
	__swig_getmethods__["second"] = _npstat.LDoubleLDoublePair_second_get
	if _newclass:
	second = _swig_property(_npstat.LDoubleLDoublePair_second_get, _npstat.LDoubleLDoublePair_second_set)
	def __len__(self):
	return 2
	def __repr__(self):
	return str((self.first, self.second))
	def __getitem__(self, index):
	if not (index % 2):
	return self.first
	else:
	return self.second
	def __setitem__(self, index, val):
	if not (index % 2):
	self.first = val
	else:
	self.second = val
	__swig_destroy__ = _npstat.delete_LDoubleLDoublePair
	__del__ = lambda self: None
	LDoubleLDoublePair_swigregister = _npstat.LDoubleLDoublePair_swigregister
	LDoubleLDoublePair_swigregister(LDoubleLDoublePair)

	class FloatDoublePair(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatDoublePair, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatDoublePair, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_FloatDoublePair(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_setmethods__["first"] = _npstat.FloatDoublePair_first_set
	__swig_getmethods__["first"] = _npstat.FloatDoublePair_first_get
	if _newclass:
	first = _swig_property(_npstat.FloatDoublePair_first_get, _npstat.FloatDoublePair_first_set)
	__swig_setmethods__["second"] = _npstat.FloatDoublePair_second_set
	__swig_getmethods__["second"] = _npstat.FloatDoublePair_second_get
	if _newclass:
	second = _swig_property(_npstat.FloatDoublePair_second_get, _npstat.FloatDoublePair_second_set)
	def __len__(self):
	return 2
	def __repr__(self):
	return str((self.first, self.second))
	def __getitem__(self, index):
	if not (index % 2):
	return self.first
	else:
	return self.second
	def __setitem__(self, index, val):
	if not (index % 2):
	self.first = val
	else:
	self.second = val
	__swig_destroy__ = _npstat.delete_FloatDoublePair
	__del__ = lambda self: None
	FloatDoublePair_swigregister = _npstat.FloatDoublePair_swigregister
	FloatDoublePair_swigregister(FloatDoublePair)

	class FloatFloatPair(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatFloatPair, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatFloatPair, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_FloatFloatPair(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_setmethods__["first"] = _npstat.FloatFloatPair_first_set
	__swig_getmethods__["first"] = _npstat.FloatFloatPair_first_get
	if _newclass:
	first = _swig_property(_npstat.FloatFloatPair_first_get, _npstat.FloatFloatPair_first_set)
	__swig_setmethods__["second"] = _npstat.FloatFloatPair_second_set
	__swig_getmethods__["second"] = _npstat.FloatFloatPair_second_get
	if _newclass:
	second = _swig_property(_npstat.FloatFloatPair_second_get, _npstat.FloatFloatPair_second_set)
	def __len__(self):
	return 2
	def __repr__(self):
	return str((self.first, self.second))
	def __getitem__(self, index):
	if not (index % 2):
	return self.first
	else:
	return self.second
	def __setitem__(self, index, val):
	if not (index % 2):
	self.first = val
	else:
	self.second = val
	__swig_destroy__ = _npstat.delete_FloatFloatPair
	__del__ = lambda self: None
	FloatFloatPair_swigregister = _npstat.FloatFloatPair_swigregister
	FloatFloatPair_swigregister(FloatFloatPair)

	class DoubleFloatPair(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleFloatPair, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleFloatPair, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_DoubleFloatPair(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_setmethods__["first"] = _npstat.DoubleFloatPair_first_set
	__swig_getmethods__["first"] = _npstat.DoubleFloatPair_first_get
	if _newclass:
	first = _swig_property(_npstat.DoubleFloatPair_first_get, _npstat.DoubleFloatPair_first_set)
	__swig_setmethods__["second"] = _npstat.DoubleFloatPair_second_set
	__swig_getmethods__["second"] = _npstat.DoubleFloatPair_second_get
	if _newclass:
	second = _swig_property(_npstat.DoubleFloatPair_second_get, _npstat.DoubleFloatPair_second_set)
	def __len__(self):
	return 2
	def __repr__(self):
	return str((self.first, self.second))
	def __getitem__(self, index):
	if not (index % 2):
	return self.first
	else:
	return self.second
	def __setitem__(self, index, val):
	if not (index % 2):
	self.first = val
	else:
	self.second = val
	__swig_destroy__ = _npstat.delete_DoubleFloatPair
	__del__ = lambda self: None
	DoubleFloatPair_swigregister = _npstat.DoubleFloatPair_swigregister
	DoubleFloatPair_swigregister(DoubleFloatPair)

	class StringStringPair(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, StringStringPair, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, StringStringPair, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_StringStringPair(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_setmethods__["first"] = _npstat.StringStringPair_first_set
	__swig_getmethods__["first"] = _npstat.StringStringPair_first_get
	if _newclass:
	first = _swig_property(_npstat.StringStringPair_first_get, _npstat.StringStringPair_first_set)
	__swig_setmethods__["second"] = _npstat.StringStringPair_second_set
	__swig_getmethods__["second"] = _npstat.StringStringPair_second_get
	if _newclass:
	second = _swig_property(_npstat.StringStringPair_second_get, _npstat.StringStringPair_second_set)
	def __len__(self):
	return 2
	def __repr__(self):
	return str((self.first, self.second))
	def __getitem__(self, index):
	if not (index % 2):
	return self.first
	else:
	return self.second
	def __setitem__(self, index, val):
	if not (index % 2):
	self.first = val
	else:
	self.second = val
	__swig_destroy__ = _npstat.delete_StringStringPair
	__del__ = lambda self: None
	StringStringPair_swigregister = _npstat.StringStringPair_swigregister
	StringStringPair_swigregister(StringStringPair)

	class FloatFloatPairVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatFloatPairVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatFloatPairVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.FloatFloatPairVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.FloatFloatPairVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.FloatFloatPairVector___bool__(self)

	def __len__(self) -> "std::vector< std::pair< float,float > >::size_type":
	return _npstat.FloatFloatPairVector___len__(self)

	def __getslice__(self, i: 'std::vector< std::pair< float,float > >::difference_type', j: 'std::vector< std::pair< float,float > >::difference_type') -> "std::vector< std::pair< float,float >,std::allocator< std::pair< float,float > > > *":
	return _npstat.FloatFloatPairVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.FloatFloatPairVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< std::pair< float,float > >::difference_type', j: 'std::vector< std::pair< float,float > >::difference_type') -> "void":
	return _npstat.FloatFloatPairVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.FloatFloatPairVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< std::pair< float,float > >::value_type const &":
	return _npstat.FloatFloatPairVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.FloatFloatPairVector___setitem__(self, *args)

	def pop(self) -> "std::vector< std::pair< float,float > >::value_type":
	return _npstat.FloatFloatPairVector_pop(self)

	def append(self, x: 'FloatFloatPair') -> "void":
	return _npstat.FloatFloatPairVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.FloatFloatPairVector_empty(self)

	def size(self) -> "std::vector< std::pair< float,float > >::size_type":
	return _npstat.FloatFloatPairVector_size(self)

	def swap(self, v: 'FloatFloatPairVector') -> "void":
	return _npstat.FloatFloatPairVector_swap(self, v)

	def begin(self) -> "std::vector< std::pair< float,float > >::iterator":
	return _npstat.FloatFloatPairVector_begin(self)

	def end(self) -> "std::vector< std::pair< float,float > >::iterator":
	return _npstat.FloatFloatPairVector_end(self)

	def rbegin(self) -> "std::vector< std::pair< float,float > >::reverse_iterator":
	return _npstat.FloatFloatPairVector_rbegin(self)

	def rend(self) -> "std::vector< std::pair< float,float > >::reverse_iterator":
	return _npstat.FloatFloatPairVector_rend(self)

	def clear(self) -> "void":
	return _npstat.FloatFloatPairVector_clear(self)

	def get_allocator(self) -> "std::vector< std::pair< float,float > >::allocator_type":
	return _npstat.FloatFloatPairVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.FloatFloatPairVector_pop_back(self)

	def erase(self, *args) -> "std::vector< std::pair< float,float > >::iterator":
	return _npstat.FloatFloatPairVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_FloatFloatPairVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'FloatFloatPair') -> "void":
	return _npstat.FloatFloatPairVector_push_back(self, x)

	def front(self) -> "std::vector< std::pair< float,float > >::value_type const &":
	return _npstat.FloatFloatPairVector_front(self)

	def back(self) -> "std::vector< std::pair< float,float > >::value_type const &":
	return _npstat.FloatFloatPairVector_back(self)

	def assign(self, n: 'std::vector< std::pair< float,float > >::size_type', x: 'FloatFloatPair') -> "void":
	return _npstat.FloatFloatPairVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.FloatFloatPairVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.FloatFloatPairVector_insert(self, *args)

	def reserve(self, n: 'std::vector< std::pair< float,float > >::size_type') -> "void":
	return _npstat.FloatFloatPairVector_reserve(self, n)

	def capacity(self) -> "std::vector< std::pair< float,float > >::size_type":
	return _npstat.FloatFloatPairVector_capacity(self)
	__swig_destroy__ = _npstat.delete_FloatFloatPairVector
	__del__ = lambda self: None
	FloatFloatPairVector_swigregister = _npstat.FloatFloatPairVector_swigregister
	FloatFloatPairVector_swigregister(FloatFloatPairVector)

	class DoubleDoublePairVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleDoublePairVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleDoublePairVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.DoubleDoublePairVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.DoubleDoublePairVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.DoubleDoublePairVector___bool__(self)

	def __len__(self) -> "std::vector< std::pair< double,double > >::size_type":
	return _npstat.DoubleDoublePairVector___len__(self)

	def __getslice__(self, i: 'std::vector< std::pair< double,double > >::difference_type', j: 'std::vector< std::pair< double,double > >::difference_type') -> "std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *":
	return _npstat.DoubleDoublePairVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.DoubleDoublePairVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< std::pair< double,double > >::difference_type', j: 'std::vector< std::pair< double,double > >::difference_type') -> "void":
	return _npstat.DoubleDoublePairVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.DoubleDoublePairVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< std::pair< double,double > >::value_type const &":
	return _npstat.DoubleDoublePairVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.DoubleDoublePairVector___setitem__(self, *args)

	def pop(self) -> "std::vector< std::pair< double,double > >::value_type":
	return _npstat.DoubleDoublePairVector_pop(self)

	def append(self, x: 'DoubleDoublePair') -> "void":
	return _npstat.DoubleDoublePairVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.DoubleDoublePairVector_empty(self)

	def size(self) -> "std::vector< std::pair< double,double > >::size_type":
	return _npstat.DoubleDoublePairVector_size(self)

	def swap(self, v: 'DoubleDoublePairVector') -> "void":
	return _npstat.DoubleDoublePairVector_swap(self, v)

	def begin(self) -> "std::vector< std::pair< double,double > >::iterator":
	return _npstat.DoubleDoublePairVector_begin(self)

	def end(self) -> "std::vector< std::pair< double,double > >::iterator":
	return _npstat.DoubleDoublePairVector_end(self)

	def rbegin(self) -> "std::vector< std::pair< double,double > >::reverse_iterator":
	return _npstat.DoubleDoublePairVector_rbegin(self)

	def rend(self) -> "std::vector< std::pair< double,double > >::reverse_iterator":
	return _npstat.DoubleDoublePairVector_rend(self)

	def clear(self) -> "void":
	return _npstat.DoubleDoublePairVector_clear(self)

	def get_allocator(self) -> "std::vector< std::pair< double,double > >::allocator_type":
	return _npstat.DoubleDoublePairVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.DoubleDoublePairVector_pop_back(self)

	def erase(self, *args) -> "std::vector< std::pair< double,double > >::iterator":
	return _npstat.DoubleDoublePairVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_DoubleDoublePairVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'DoubleDoublePair') -> "void":
	return _npstat.DoubleDoublePairVector_push_back(self, x)

	def front(self) -> "std::vector< std::pair< double,double > >::value_type const &":
	return _npstat.DoubleDoublePairVector_front(self)

	def back(self) -> "std::vector< std::pair< double,double > >::value_type const &":
	return _npstat.DoubleDoublePairVector_back(self)

	def assign(self, n: 'std::vector< std::pair< double,double > >::size_type', x: 'DoubleDoublePair') -> "void":
	return _npstat.DoubleDoublePairVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.DoubleDoublePairVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.DoubleDoublePairVector_insert(self, *args)

	def reserve(self, n: 'std::vector< std::pair< double,double > >::size_type') -> "void":
	return _npstat.DoubleDoublePairVector_reserve(self, n)

	def capacity(self) -> "std::vector< std::pair< double,double > >::size_type":
	return _npstat.DoubleDoublePairVector_capacity(self)
	__swig_destroy__ = _npstat.delete_DoubleDoublePairVector
	__del__ = lambda self: None
	DoubleDoublePairVector_swigregister = _npstat.DoubleDoublePairVector_swigregister
	DoubleDoublePairVector_swigregister(DoubleDoublePairVector)

	class FloatDoublePairVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatDoublePairVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatDoublePairVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.FloatDoublePairVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.FloatDoublePairVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.FloatDoublePairVector___bool__(self)

	def __len__(self) -> "std::vector< std::pair< float,double > >::size_type":
	return _npstat.FloatDoublePairVector___len__(self)

	def __getslice__(self, i: 'std::vector< std::pair< float,double > >::difference_type', j: 'std::vector< std::pair< float,double > >::difference_type') -> "std::vector< std::pair< float,double >,std::allocator< std::pair< float,double > > > *":
	return _npstat.FloatDoublePairVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.FloatDoublePairVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< std::pair< float,double > >::difference_type', j: 'std::vector< std::pair< float,double > >::difference_type') -> "void":
	return _npstat.FloatDoublePairVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.FloatDoublePairVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< std::pair< float,double > >::value_type const &":
	return _npstat.FloatDoublePairVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.FloatDoublePairVector___setitem__(self, *args)

	def pop(self) -> "std::vector< std::pair< float,double > >::value_type":
	return _npstat.FloatDoublePairVector_pop(self)

	def append(self, x: 'FloatDoublePair') -> "void":
	return _npstat.FloatDoublePairVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.FloatDoublePairVector_empty(self)

	def size(self) -> "std::vector< std::pair< float,double > >::size_type":
	return _npstat.FloatDoublePairVector_size(self)

	def swap(self, v: 'FloatDoublePairVector') -> "void":
	return _npstat.FloatDoublePairVector_swap(self, v)

	def begin(self) -> "std::vector< std::pair< float,double > >::iterator":
	return _npstat.FloatDoublePairVector_begin(self)

	def end(self) -> "std::vector< std::pair< float,double > >::iterator":
	return _npstat.FloatDoublePairVector_end(self)

	def rbegin(self) -> "std::vector< std::pair< float,double > >::reverse_iterator":
	return _npstat.FloatDoublePairVector_rbegin(self)

	def rend(self) -> "std::vector< std::pair< float,double > >::reverse_iterator":
	return _npstat.FloatDoublePairVector_rend(self)

	def clear(self) -> "void":
	return _npstat.FloatDoublePairVector_clear(self)

	def get_allocator(self) -> "std::vector< std::pair< float,double > >::allocator_type":
	return _npstat.FloatDoublePairVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.FloatDoublePairVector_pop_back(self)

	def erase(self, *args) -> "std::vector< std::pair< float,double > >::iterator":
	return _npstat.FloatDoublePairVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_FloatDoublePairVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'FloatDoublePair') -> "void":
	return _npstat.FloatDoublePairVector_push_back(self, x)

	def front(self) -> "std::vector< std::pair< float,double > >::value_type const &":
	return _npstat.FloatDoublePairVector_front(self)

	def back(self) -> "std::vector< std::pair< float,double > >::value_type const &":
	return _npstat.FloatDoublePairVector_back(self)

	def assign(self, n: 'std::vector< std::pair< float,double > >::size_type', x: 'FloatDoublePair') -> "void":
	return _npstat.FloatDoublePairVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.FloatDoublePairVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.FloatDoublePairVector_insert(self, *args)

	def reserve(self, n: 'std::vector< std::pair< float,double > >::size_type') -> "void":
	return _npstat.FloatDoublePairVector_reserve(self, n)

	def capacity(self) -> "std::vector< std::pair< float,double > >::size_type":
	return _npstat.FloatDoublePairVector_capacity(self)
	__swig_destroy__ = _npstat.delete_FloatDoublePairVector
	__del__ = lambda self: None
	FloatDoublePairVector_swigregister = _npstat.FloatDoublePairVector_swigregister
	FloatDoublePairVector_swigregister(FloatDoublePairVector)

	class DoubleFloatPairVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleFloatPairVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleFloatPairVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.DoubleFloatPairVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.DoubleFloatPairVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.DoubleFloatPairVector___bool__(self)

	def __len__(self) -> "std::vector< std::pair< double,float > >::size_type":
	return _npstat.DoubleFloatPairVector___len__(self)

	def __getslice__(self, i: 'std::vector< std::pair< double,float > >::difference_type', j: 'std::vector< std::pair< double,float > >::difference_type') -> "std::vector< std::pair< double,float >,std::allocator< std::pair< double,float > > > *":
	return _npstat.DoubleFloatPairVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.DoubleFloatPairVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< std::pair< double,float > >::difference_type', j: 'std::vector< std::pair< double,float > >::difference_type') -> "void":
	return _npstat.DoubleFloatPairVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.DoubleFloatPairVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< std::pair< double,float > >::value_type const &":
	return _npstat.DoubleFloatPairVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.DoubleFloatPairVector___setitem__(self, *args)

	def pop(self) -> "std::vector< std::pair< double,float > >::value_type":
	return _npstat.DoubleFloatPairVector_pop(self)

	def append(self, x: 'DoubleFloatPair') -> "void":
	return _npstat.DoubleFloatPairVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.DoubleFloatPairVector_empty(self)

	def size(self) -> "std::vector< std::pair< double,float > >::size_type":
	return _npstat.DoubleFloatPairVector_size(self)

	def swap(self, v: 'DoubleFloatPairVector') -> "void":
	return _npstat.DoubleFloatPairVector_swap(self, v)

	def begin(self) -> "std::vector< std::pair< double,float > >::iterator":
	return _npstat.DoubleFloatPairVector_begin(self)

	def end(self) -> "std::vector< std::pair< double,float > >::iterator":
	return _npstat.DoubleFloatPairVector_end(self)

	def rbegin(self) -> "std::vector< std::pair< double,float > >::reverse_iterator":
	return _npstat.DoubleFloatPairVector_rbegin(self)

	def rend(self) -> "std::vector< std::pair< double,float > >::reverse_iterator":
	return _npstat.DoubleFloatPairVector_rend(self)

	def clear(self) -> "void":
	return _npstat.DoubleFloatPairVector_clear(self)

	def get_allocator(self) -> "std::vector< std::pair< double,float > >::allocator_type":
	return _npstat.DoubleFloatPairVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.DoubleFloatPairVector_pop_back(self)

	def erase(self, *args) -> "std::vector< std::pair< double,float > >::iterator":
	return _npstat.DoubleFloatPairVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_DoubleFloatPairVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'DoubleFloatPair') -> "void":
	return _npstat.DoubleFloatPairVector_push_back(self, x)

	def front(self) -> "std::vector< std::pair< double,float > >::value_type const &":
	return _npstat.DoubleFloatPairVector_front(self)

	def back(self) -> "std::vector< std::pair< double,float > >::value_type const &":
	return _npstat.DoubleFloatPairVector_back(self)

	def assign(self, n: 'std::vector< std::pair< double,float > >::size_type', x: 'DoubleFloatPair') -> "void":
	return _npstat.DoubleFloatPairVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.DoubleFloatPairVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.DoubleFloatPairVector_insert(self, *args)

	def reserve(self, n: 'std::vector< std::pair< double,float > >::size_type') -> "void":
	return _npstat.DoubleFloatPairVector_reserve(self, n)

	def capacity(self) -> "std::vector< std::pair< double,float > >::size_type":
	return _npstat.DoubleFloatPairVector_capacity(self)
	__swig_destroy__ = _npstat.delete_DoubleFloatPairVector
	__del__ = lambda self: None
	DoubleFloatPairVector_swigregister = _npstat.DoubleFloatPairVector_swigregister
	DoubleFloatPairVector_swigregister(DoubleFloatPairVector)

	class FloatVectorVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatVectorVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatVectorVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.FloatVectorVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.FloatVectorVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.FloatVectorVector___bool__(self)

	def __len__(self) -> "std::vector< std::vector< float > >::size_type":
	return _npstat.FloatVectorVector___len__(self)

	def __getslice__(self, i: 'std::vector< std::vector< float > >::difference_type', j: 'std::vector< std::vector< float > >::difference_type') -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > *":
	return _npstat.FloatVectorVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.FloatVectorVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< std::vector< float > >::difference_type', j: 'std::vector< std::vector< float > >::difference_type') -> "void":
	return _npstat.FloatVectorVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.FloatVectorVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< std::vector< float > >::value_type const &":
	return _npstat.FloatVectorVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.FloatVectorVector___setitem__(self, *args)

	def pop(self) -> "std::vector< std::vector< float > >::value_type":
	return _npstat.FloatVectorVector_pop(self)

	def append(self, x: 'FloatVector') -> "void":
	return _npstat.FloatVectorVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.FloatVectorVector_empty(self)

	def size(self) -> "std::vector< std::vector< float > >::size_type":
	return _npstat.FloatVectorVector_size(self)

	def swap(self, v: 'FloatVectorVector') -> "void":
	return _npstat.FloatVectorVector_swap(self, v)

	def begin(self) -> "std::vector< std::vector< float > >::iterator":
	return _npstat.FloatVectorVector_begin(self)

	def end(self) -> "std::vector< std::vector< float > >::iterator":
	return _npstat.FloatVectorVector_end(self)

	def rbegin(self) -> "std::vector< std::vector< float > >::reverse_iterator":
	return _npstat.FloatVectorVector_rbegin(self)

	def rend(self) -> "std::vector< std::vector< float > >::reverse_iterator":
	return _npstat.FloatVectorVector_rend(self)

	def clear(self) -> "void":
	return _npstat.FloatVectorVector_clear(self)

	def get_allocator(self) -> "std::vector< std::vector< float > >::allocator_type":
	return _npstat.FloatVectorVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.FloatVectorVector_pop_back(self)

	def erase(self, *args) -> "std::vector< std::vector< float > >::iterator":
	return _npstat.FloatVectorVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_FloatVectorVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'FloatVector') -> "void":
	return _npstat.FloatVectorVector_push_back(self, x)

	def front(self) -> "std::vector< std::vector< float > >::value_type const &":
	return _npstat.FloatVectorVector_front(self)

	def back(self) -> "std::vector< std::vector< float > >::value_type const &":
	return _npstat.FloatVectorVector_back(self)

	def assign(self, n: 'std::vector< std::vector< float > >::size_type', x: 'FloatVector') -> "void":
	return _npstat.FloatVectorVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.FloatVectorVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.FloatVectorVector_insert(self, *args)

	def reserve(self, n: 'std::vector< std::vector< float > >::size_type') -> "void":
	return _npstat.FloatVectorVector_reserve(self, n)

	def capacity(self) -> "std::vector< std::vector< float > >::size_type":
	return _npstat.FloatVectorVector_capacity(self)
	__swig_destroy__ = _npstat.delete_FloatVectorVector
	__del__ = lambda self: None
	FloatVectorVector_swigregister = _npstat.FloatVectorVector_swigregister
	FloatVectorVector_swigregister(FloatVectorVector)

	class DoubleVectorVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVectorVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleVectorVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.DoubleVectorVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.DoubleVectorVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.DoubleVectorVector___bool__(self)

	def __len__(self) -> "std::vector< std::vector< double > >::size_type":
	return _npstat.DoubleVectorVector___len__(self)

	def __getslice__(self, i: 'std::vector< std::vector< double > >::difference_type', j: 'std::vector< std::vector< double > >::difference_type') -> "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *":
	return _npstat.DoubleVectorVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.DoubleVectorVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< std::vector< double > >::difference_type', j: 'std::vector< std::vector< double > >::difference_type') -> "void":
	return _npstat.DoubleVectorVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.DoubleVectorVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< std::vector< double > >::value_type const &":
	return _npstat.DoubleVectorVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.DoubleVectorVector___setitem__(self, *args)

	def pop(self) -> "std::vector< std::vector< double > >::value_type":
	return _npstat.DoubleVectorVector_pop(self)

	def append(self, x: 'DoubleVector') -> "void":
	return _npstat.DoubleVectorVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.DoubleVectorVector_empty(self)

	def size(self) -> "std::vector< std::vector< double > >::size_type":
	return _npstat.DoubleVectorVector_size(self)

	def swap(self, v: 'DoubleVectorVector') -> "void":
	return _npstat.DoubleVectorVector_swap(self, v)

	def begin(self) -> "std::vector< std::vector< double > >::iterator":
	return _npstat.DoubleVectorVector_begin(self)

	def end(self) -> "std::vector< std::vector< double > >::iterator":
	return _npstat.DoubleVectorVector_end(self)

	def rbegin(self) -> "std::vector< std::vector< double > >::reverse_iterator":
	return _npstat.DoubleVectorVector_rbegin(self)

	def rend(self) -> "std::vector< std::vector< double > >::reverse_iterator":
	return _npstat.DoubleVectorVector_rend(self)

	def clear(self) -> "void":
	return _npstat.DoubleVectorVector_clear(self)

	def get_allocator(self) -> "std::vector< std::vector< double > >::allocator_type":
	return _npstat.DoubleVectorVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.DoubleVectorVector_pop_back(self)

	def erase(self, *args) -> "std::vector< std::vector< double > >::iterator":
	return _npstat.DoubleVectorVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_DoubleVectorVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'DoubleVector') -> "void":
	return _npstat.DoubleVectorVector_push_back(self, x)

	def front(self) -> "std::vector< std::vector< double > >::value_type const &":
	return _npstat.DoubleVectorVector_front(self)

	def back(self) -> "std::vector< std::vector< double > >::value_type const &":
	return _npstat.DoubleVectorVector_back(self)

	def assign(self, n: 'std::vector< std::vector< double > >::size_type', x: 'DoubleVector') -> "void":
	return _npstat.DoubleVectorVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.DoubleVectorVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.DoubleVectorVector_insert(self, *args)

	def reserve(self, n: 'std::vector< std::vector< double > >::size_type') -> "void":
	return _npstat.DoubleVectorVector_reserve(self, n)

	def capacity(self) -> "std::vector< std::vector< double > >::size_type":
	return _npstat.DoubleVectorVector_capacity(self)
	__swig_destroy__ = _npstat.delete_DoubleVectorVector
	__del__ = lambda self: None
	DoubleVectorVector_swigregister = _npstat.DoubleVectorVector_swigregister
	DoubleVectorVector_swigregister(DoubleVectorVector)


	def getBool(p: 'bool const *') -> "bool":
	return _npstat.getBool(p)
	getBool = _npstat.getBool

	def getChar(p: 'char const *') -> "char":
	return _npstat.getChar(p)
	getChar = _npstat.getChar

	def getUChar(p: 'unsigned char const *') -> "unsigned char":
	return _npstat.getUChar(p)
	getUChar = _npstat.getUChar

	def getSChar(p: 'signed char const *') -> "signed char":
	return _npstat.getSChar(p)
	getSChar = _npstat.getSChar

	def getShort(p: 'short const *') -> "short":
	return _npstat.getShort(p)
	getShort = _npstat.getShort

	def getUShort(p: 'unsigned short const *') -> "unsigned short":
	return _npstat.getUShort(p)
	getUShort = _npstat.getUShort

	def getInt(p: 'int const *') -> "int":
	return _npstat.getInt(p)
	getInt = _npstat.getInt

	def getLong(p: 'long const *') -> "long":
	return _npstat.getLong(p)
	getLong = _npstat.getLong

	def getLLong(p: 'long long const *') -> "long long":
	return _npstat.getLLong(p)
	getLLong = _npstat.getLLong

	def getUInt(p: 'unsigned int const *') -> "unsigned int":
	return _npstat.getUInt(p)
	getUInt = _npstat.getUInt

	def getULong(p: 'unsigned long const *') -> "unsigned long":
	return _npstat.getULong(p)
	getULong = _npstat.getULong

	def getULLong(p: 'unsigned long long const *') -> "unsigned long long":
	return _npstat.getULLong(p)
	getULLong = _npstat.getULLong

	def getFloat(p: 'float const *') -> "float":
	return _npstat.getFloat(p)
	getFloat = _npstat.getFloat

	def getDouble(p: 'double const *') -> "double":
	return _npstat.getDouble(p)
	getDouble = _npstat.getDouble

	def getLDouble(p: 'long double const *') -> "long double":
	return _npstat.getLDouble(p)
	getLDouble = _npstat.getLDouble

	def getCFloat(p: 'std::complex< float > const *') -> "std::complex< float >":
	return _npstat.getCFloat(p)
	getCFloat = _npstat.getCFloat

	def getCDouble(p: 'std::complex< double > const *') -> "std::complex< double >":
	return _npstat.getCDouble(p)
	getCDouble = _npstat.getCDouble

	def getCLDouble(p: 'std::complex< long double > const *') -> "std::complex< long double >":
	return _npstat.getCLDouble(p)
	getCLDouble = _npstat.getCLDouble

	def getString(p: 'string') -> "std::basic_string< char,std::char_traits< char >,std::allocator< char > >":
	return _npstat.getString(p)
	getString = _npstat.getString

	def assignBool(p: 'bool *', value: 'bool const &') -> "void":
	return _npstat.assignBool(p, value)
	assignBool = _npstat.assignBool

	def assignChar(p: 'char *', value: 'char const &') -> "void":
	return _npstat.assignChar(p, value)
	assignChar = _npstat.assignChar

	def assignUChar(p: 'unsigned char *', value: 'unsigned char const &') -> "void":
	return _npstat.assignUChar(p, value)
	assignUChar = _npstat.assignUChar

	def assignSChar(p: 'signed char *', value: 'signed char const &') -> "void":
	return _npstat.assignSChar(p, value)
	assignSChar = _npstat.assignSChar

	def assignShort(p: 'short *', value: 'short const &') -> "void":
	return _npstat.assignShort(p, value)
	assignShort = _npstat.assignShort

	def assignUShort(p: 'unsigned short *', value: 'unsigned short const &') -> "void":
	return _npstat.assignUShort(p, value)
	assignUShort = _npstat.assignUShort

	def assignInt(p: 'int *', value: 'int const &') -> "void":
	return _npstat.assignInt(p, value)
	assignInt = _npstat.assignInt

	def assignLong(p: 'long *', value: 'long const &') -> "void":
	return _npstat.assignLong(p, value)
	assignLong = _npstat.assignLong

	def assignLLong(p: 'long long *', value: 'long long const &') -> "void":
	return _npstat.assignLLong(p, value)
	assignLLong = _npstat.assignLLong

	def assignUInt(p: 'unsigned int *', value: 'unsigned int const &') -> "void":
	return _npstat.assignUInt(p, value)
	assignUInt = _npstat.assignUInt

	def assignULong(p: 'unsigned long *', value: 'unsigned long const &') -> "void":
	return _npstat.assignULong(p, value)
	assignULong = _npstat.assignULong

	def assignULLong(p: 'unsigned long long *', value: 'unsigned long long const &') -> "void":
	return _npstat.assignULLong(p, value)
	assignULLong = _npstat.assignULLong

	def assignFloat(p: 'float *', value: 'float const &') -> "void":
	return _npstat.assignFloat(p, value)
	assignFloat = _npstat.assignFloat

	def assignDouble(p: 'double *', value: 'double const &') -> "void":
	return _npstat.assignDouble(p, value)
	assignDouble = _npstat.assignDouble

	def assignLDouble(p: 'long double *', value: 'long double const &') -> "void":
	return _npstat.assignLDouble(p, value)
	assignLDouble = _npstat.assignLDouble

	def assignCFloat(p: 'std::complex< float > *', value: 'std::complex< float > const &') -> "void":
	return _npstat.assignCFloat(p, value)
	assignCFloat = _npstat.assignCFloat

	def assignCDouble(p: 'std::complex< double > *', value: 'std::complex< double > const &') -> "void":
	return _npstat.assignCDouble(p, value)
	assignCDouble = _npstat.assignCDouble

	def assignCLDouble(p: 'std::complex< long double > *', value: 'std::complex< long double > const &') -> "void":
	return _npstat.assignCLDouble(p, value)
	assignCLDouble = _npstat.assignCLDouble

	def assignString(p: 'string', value: 'string') -> "void":
	return _npstat.assignString(p, value)
	assignString = _npstat.assignString
	class AbsRandomGenerator(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsRandomGenerator, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, AbsRandomGenerator, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsRandomGenerator
	__del__ = lambda self: None

	def dim(self) -> "unsigned int":
	return _npstat.AbsRandomGenerator_dim(self)

	def maxPoints(self) -> "unsigned long long":
	return _npstat.AbsRandomGenerator_maxPoints(self)

	def __call__(self) -> "double":
	return _npstat.AbsRandomGenerator___call__(self)

	def run(self, buf: 'double *', bufLen: 'unsigned int const', nPt: 'unsigned int const') -> "void":
	return _npstat.AbsRandomGenerator_run(self, buf, bufLen, nPt)

	def generate(self, npoints: 'unsigned int') -> "std::vector< double,std::allocator< double > >":
	return _npstat.AbsRandomGenerator_generate(self, npoints)
	AbsRandomGenerator_swigregister = _npstat.AbsRandomGenerator_swigregister
	AbsRandomGenerator_swigregister(AbsRandomGenerator)

	class WrappedRandomGen(AbsRandomGenerator):
	__swig_setmethods__ = {}
	for _s in [AbsRandomGenerator]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, WrappedRandomGen, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRandomGenerator]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, WrappedRandomGen, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'double (*)()'):
	this = _npstat.new_WrappedRandomGen(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_WrappedRandomGen
	__del__ = lambda self: None

	def dim(self) -> "unsigned int":
	return _npstat.WrappedRandomGen_dim(self)

	def __call__(self) -> "double":
	return _npstat.WrappedRandomGen___call__(self)
	WrappedRandomGen_swigregister = _npstat.WrappedRandomGen_swigregister
	WrappedRandomGen_swigregister(WrappedRandomGen)

	class MersenneTwister(AbsRandomGenerator):
	__swig_setmethods__ = {}
	for _s in [AbsRandomGenerator]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, MersenneTwister, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRandomGenerator]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, MersenneTwister, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_MersenneTwister(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_MersenneTwister
	__del__ = lambda self: None

	def dim(self) -> "unsigned int":
	return _npstat.MersenneTwister_dim(self)

	def __call__(self) -> "double":
	return _npstat.MersenneTwister___call__(self)
	MersenneTwister_swigregister = _npstat.MersenneTwister_swigregister
	MersenneTwister_swigregister(MersenneTwister)


	def orderedPermutation(permutationNumber: 'unsigned long', permutation: 'unsigned int *', permLen: 'unsigned int') -> "void":
	return _npstat.orderedPermutation(permutationNumber, permutation, permLen)
	orderedPermutation = _npstat.orderedPermutation

	def randomPermutation(gen: 'AbsRandomGenerator', permutation: 'unsigned int *', permLen: 'unsigned int') -> "void":
	return _npstat.randomPermutation(gen, permutation, permLen)
	randomPermutation = _npstat.randomPermutation

	def permutationNumber(permutation: 'unsigned int const *', permLen: 'unsigned int') -> "unsigned long":
	return _npstat.permutationNumber(permutation, permLen)
	permutationNumber = _npstat.permutationNumber

	def factorial(n: 'unsigned int') -> "unsigned long":
	return _npstat.factorial(n)
	factorial = _npstat.factorial

	def intPower(a: 'unsigned int', n: 'unsigned int') -> "unsigned long":
	return _npstat.intPower(a, n)
	intPower = _npstat.intPower

	def ldfactorial(n: 'unsigned int') -> "long double":
	return _npstat.ldfactorial(n)
	ldfactorial = _npstat.ldfactorial

	def logfactorial(n: 'unsigned long') -> "long double":
	return _npstat.logfactorial(n)
	logfactorial = _npstat.logfactorial
	class RegularSampler1D(AbsRandomGenerator):
	__swig_setmethods__ = {}
	for _s in [AbsRandomGenerator]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, RegularSampler1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRandomGenerator]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, RegularSampler1D, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_RegularSampler1D()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_RegularSampler1D
	__del__ = lambda self: None

	def dim(self) -> "unsigned int":
	return _npstat.RegularSampler1D_dim(self)

	def nCalls(self) -> "unsigned long long":
	return _npstat.RegularSampler1D_nCalls(self)

	def __call__(self) -> "double":
	return _npstat.RegularSampler1D___call__(self)

	def reset(self) -> "void":
	return _npstat.RegularSampler1D_reset(self)
	if _newclass:
	uniformCount = staticmethod(_npstat.RegularSampler1D_uniformCount)
	else:
	uniformCount = _npstat.RegularSampler1D_uniformCount
	RegularSampler1D_swigregister = _npstat.RegularSampler1D_swigregister
	RegularSampler1D_swigregister(RegularSampler1D)

	def RegularSampler1D_uniformCount(level: 'unsigned int') -> "unsigned long long":
	return _npstat.RegularSampler1D_uniformCount(level)
	RegularSampler1D_uniformCount = _npstat.RegularSampler1D_uniformCount

	class SobolGenerator(AbsRandomGenerator):
	__swig_setmethods__ = {}
	for _s in [AbsRandomGenerator]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, SobolGenerator, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRandomGenerator]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, SobolGenerator, name)
	__repr__ = _swig_repr
	DIM_MAX = _npstat.SobolGenerator_DIM_MAX
	LOG_MAX = _npstat.SobolGenerator_LOG_MAX

	def __init__(self, *args):
	this = _npstat.new_SobolGenerator(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_SobolGenerator
	__del__ = lambda self: None

	def dim(self) -> "unsigned int":
	return _npstat.SobolGenerator_dim(self)

	def run(self, buf: 'double *', bufSize: 'unsigned int', nPoints: 'unsigned int') -> "void":
	return _npstat.SobolGenerator_run(self, buf, bufSize, nPoints)

	def __call__(self) -> "double":
	return _npstat.SobolGenerator___call__(self)

	def maxPoints(self) -> "unsigned long long":
	return _npstat.SobolGenerator_maxPoints(self)
	SobolGenerator_swigregister = _npstat.SobolGenerator_swigregister
	SobolGenerator_swigregister(SobolGenerator)

	class HOSobolGenerator(SobolGenerator):
	__swig_setmethods__ = {}
	for _s in [SobolGenerator]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, HOSobolGenerator, name, value)
	__swig_getmethods__ = {}
	for _s in [SobolGenerator]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, HOSobolGenerator, name)
	__repr__ = _swig_repr

	def __init__(self, dim: 'unsigned int', interlacingFactor: 'unsigned int', maxPowerOfTwo: 'unsigned int', nSkip: 'unsigned int'=0):
	this = _npstat.new_HOSobolGenerator(dim, interlacingFactor, maxPowerOfTwo, nSkip)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_HOSobolGenerator
	__del__ = lambda self: None

	def dim(self) -> "unsigned int":
	return _npstat.HOSobolGenerator_dim(self)

	def run(self, buf: 'double *', bufSize: 'unsigned int', nPoints: 'unsigned int') -> "void":
	return _npstat.HOSobolGenerator_run(self, buf, bufSize, nPoints)
	HOSobolGenerator_swigregister = _npstat.HOSobolGenerator_swigregister
	HOSobolGenerator_swigregister(HOSobolGenerator)

	class EquidistantSampler1D(AbsRandomGenerator):
	__swig_setmethods__ = {}
	for _s in [AbsRandomGenerator]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, EquidistantSampler1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRandomGenerator]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, EquidistantSampler1D, name)
	__repr__ = _swig_repr

	def __init__(self, nIntervals: 'unsigned long long', increasingOrder: 'bool'=True):
	this = _npstat.new_EquidistantSampler1D(nIntervals, increasingOrder)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_EquidistantSampler1D
	__del__ = lambda self: None

	def dim(self) -> "unsigned int":
	return _npstat.EquidistantSampler1D_dim(self)

	def nCalls(self) -> "unsigned long long":
	return _npstat.EquidistantSampler1D_nCalls(self)

	def maxPoints(self) -> "unsigned long long":
	return _npstat.EquidistantSampler1D_maxPoints(self)

	def __call__(self) -> "double":
	return _npstat.EquidistantSampler1D___call__(self)

	def reset(self) -> "void":
	return _npstat.EquidistantSampler1D_reset(self)
	EquidistantSampler1D_swigregister = _npstat.EquidistantSampler1D_swigregister
	EquidistantSampler1D_swigregister(EquidistantSampler1D)


	def convertToSphericalRandom(rnd: 'double const ', dim: 'unsigned int', direction: 'double ', getRadialRandom: 'bool'=True) -> "double":
	return _npstat.convertToSphericalRandom(rnd, dim, direction, getRadialRandom)
	convertToSphericalRandom = _npstat.convertToSphericalRandom
	class RandomSequenceRepeater(AbsRandomGenerator):
	__swig_setmethods__ = {}
	for _s in [AbsRandomGenerator]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, RandomSequenceRepeater, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRandomGenerator]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, RandomSequenceRepeater, name)
	__repr__ = _swig_repr

	def __init__(self, original: 'AbsRandomGenerator'):
	this = _npstat.new_RandomSequenceRepeater(original)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_RandomSequenceRepeater
	__del__ = lambda self: None

	def dim(self) -> "unsigned int":
	return _npstat.RandomSequenceRepeater_dim(self)

	def __call__(self) -> "double":
	return _npstat.RandomSequenceRepeater___call__(self)

	def run(self, buf: 'double *', bufLen: 'unsigned int const', nPt: 'unsigned int const') -> "void":
	return _npstat.RandomSequenceRepeater_run(self, buf, bufLen, nPt)

	def repeat(self) -> "void":
	return _npstat.RandomSequenceRepeater_repeat(self)

	def clear(self) -> "void":
	return _npstat.RandomSequenceRepeater_clear(self)

	def skip(self, nSkip: 'unsigned long') -> "void":
	return _npstat.RandomSequenceRepeater_skip(self, nSkip)
	RandomSequenceRepeater_swigregister = _npstat.RandomSequenceRepeater_swigregister
	RandomSequenceRepeater_swigregister(RandomSequenceRepeater)

	class Column(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, Column, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, Column, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Column(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_Column
	__del__ = lambda self: None
	Column_swigregister = _npstat.Column_swigregister
	Column_swigregister(Column)

	class ClassId(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, ClassId, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, ClassId, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_ClassId(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def name(self) -> "std::string const &":
	return _npstat.ClassId_name(self)

	def version(self) -> "unsigned int":
	return _npstat.ClassId_version(self)

	def isPointer(self) -> "bool":
	return _npstat.ClassId_isPointer(self)

	def id(self) -> "std::string const &":
	return _npstat.ClassId_id(self)

	def isTemplate(self) -> "bool":
	return _npstat.ClassId_isTemplate(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.ClassId_write(self, of)

	def __eq__(self, r: 'ClassId') -> "bool":
	return _npstat.ClassId___eq__(self, r)

	def __ne__(self, r: 'ClassId') -> "bool":
	return _npstat.ClassId___ne__(self, r)

	def __lt__(self, r: 'ClassId') -> "bool":
	return _npstat.ClassId___lt__(self, r)

	def __gt__(self, r: 'ClassId') -> "bool":
	return _npstat.ClassId___gt__(self, r)

	def setVersion(self, newVersion: 'unsigned int') -> "void":
	return _npstat.ClassId_setVersion(self, newVersion)

	def ensureSameId(self, id: 'ClassId') -> "void":
	return _npstat.ClassId_ensureSameId(self, id)

	def ensureSameName(self, id: 'ClassId') -> "void":
	return _npstat.ClassId_ensureSameName(self, id)

	def ensureSameVersion(self, id: 'ClassId') -> "void":
	return _npstat.ClassId_ensureSameVersion(self, id)

	def ensureVersionInRange(self, min: 'unsigned int', max: 'unsigned int') -> "void":
	return _npstat.ClassId_ensureVersionInRange(self, min, max)
	if _newclass:
	invalidId = staticmethod(_npstat.ClassId_invalidId)
	else:
	invalidId = _npstat.ClassId_invalidId
	__swig_destroy__ = _npstat.delete_ClassId
	__del__ = lambda self: None
	ClassId_swigregister = _npstat.ClassId_swigregister
	ClassId_swigregister(ClassId)

	def ClassId_invalidId() -> "gs::ClassId":
	return _npstat.ClassId_invalidId()
	ClassId_invalidId = _npstat.ClassId_invalidId

	class SameClassId(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, SameClassId, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, SameClassId, name)
	__repr__ = _swig_repr
	if _newclass:
	compatible = staticmethod(_npstat.SameClassId_compatible)
	else:
	compatible = _npstat.SameClassId_compatible

	def __init__(self):
	this = _npstat.new_SameClassId()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_SameClassId
	__del__ = lambda self: None
	SameClassId_swigregister = _npstat.SameClassId_swigregister
	SameClassId_swigregister(SameClassId)

	def SameClassId_compatible(id1: 'ClassId', id2: 'ClassId') -> "bool":
	return _npstat.SameClassId_compatible(id1, id2)
	SameClassId_compatible = _npstat.SameClassId_compatible

	class SameClassName(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, SameClassName, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, SameClassName, name)
	__repr__ = _swig_repr
	if _newclass:
	compatible = staticmethod(_npstat.SameClassName_compatible)
	else:
	compatible = _npstat.SameClassName_compatible

	def __init__(self):
	this = _npstat.new_SameClassName()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_SameClassName
	__del__ = lambda self: None
	SameClassName_swigregister = _npstat.SameClassName_swigregister
	SameClassName_swigregister(SameClassName)

	def SameClassName_compatible(id1: 'ClassId', id2: 'ClassId') -> "bool":
	return _npstat.SameClassName_compatible(id1, id2)
	SameClassName_compatible = _npstat.SameClassName_compatible

	class FloatSampleAccumulator(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatSampleAccumulator, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatSampleAccumulator, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_FloatSampleAccumulator()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def count(self) -> "unsigned long":
	return _npstat.FloatSampleAccumulator_count(self)

	def min(self) -> "float":
	return _npstat.FloatSampleAccumulator_min(self)

	def max(self) -> "float":
	return _npstat.FloatSampleAccumulator_max(self)

	def mean(self) -> "long double":
	return _npstat.FloatSampleAccumulator_mean(self)

	def stdev(self) -> "long double":
	return _npstat.FloatSampleAccumulator_stdev(self)

	def meanUncertainty(self) -> "long double":
	return _npstat.FloatSampleAccumulator_meanUncertainty(self)

	def median(self) -> "float":
	return _npstat.FloatSampleAccumulator_median(self)

	def cdf(self, value: 'float') -> "double":
	return _npstat.FloatSampleAccumulator_cdf(self, value)

	def nBelow(self, value: 'float') -> "unsigned long":
	return _npstat.FloatSampleAccumulator_nBelow(self, value)

	def quantile(self, x: 'double') -> "float":
	return _npstat.FloatSampleAccumulator_quantile(self, x)

	def location(self) -> "float":
	return _npstat.FloatSampleAccumulator_location(self)

	def rangeDown(self) -> "float":
	return _npstat.FloatSampleAccumulator_rangeDown(self)

	def rangeUp(self) -> "float":
	return _npstat.FloatSampleAccumulator_rangeUp(self)

	def sigmaRange(self) -> "float":
	return _npstat.FloatSampleAccumulator_sigmaRange(self)

	def noThrowMean(self, valueIfNoData: 'long double const &') -> "long double":
	return _npstat.FloatSampleAccumulator_noThrowMean(self, valueIfNoData)

	def noThrowStdev(self, valueIfNoData: 'long double const &') -> "long double":
	return _npstat.FloatSampleAccumulator_noThrowStdev(self, valueIfNoData)

	def noThrowMeanUncertainty(self, valueIfNoData: 'long double const &') -> "long double":
	return _npstat.FloatSampleAccumulator_noThrowMeanUncertainty(self, valueIfNoData)

	def data(self) -> "float const *":
	return _npstat.FloatSampleAccumulator_data(self)

	def __eq__(self, r: 'FloatSampleAccumulator') -> "bool":
	return _npstat.FloatSampleAccumulator___eq__(self, r)

	def __ne__(self, r: 'FloatSampleAccumulator') -> "bool":
	return _npstat.FloatSampleAccumulator___ne__(self, r)

	def accumulate(self, *args) -> "void":
	return _npstat.FloatSampleAccumulator_accumulate(self, *args)

	def __iadd__(self, *args) -> "npstat::SampleAccumulator< float,long double > &":
	return _npstat.FloatSampleAccumulator___iadd__(self, *args)

	def __add__(self, r: 'FloatSampleAccumulator') -> "npstat::SampleAccumulator< float,long double >":
	return _npstat.FloatSampleAccumulator___add__(self, r)

	def reset(self) -> "void":
	return _npstat.FloatSampleAccumulator_reset(self)

	def reserve(self, n: 'unsigned long const') -> "void":
	return _npstat.FloatSampleAccumulator_reserve(self, n)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatSampleAccumulator_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatSampleAccumulator_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatSampleAccumulator_classname)
	else:
	classname = _npstat.FloatSampleAccumulator_classname
	if _newclass:
	version = staticmethod(_npstat.FloatSampleAccumulator_version)
	else:
	version = _npstat.FloatSampleAccumulator_version
	if _newclass:
	restore = staticmethod(_npstat.FloatSampleAccumulator_restore)
	else:
	restore = _npstat.FloatSampleAccumulator_restore

	def __mul__(self, r: 'double const') -> "npstat::SampleAccumulator< float,long double >":
	return _npstat.FloatSampleAccumulator___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::SampleAccumulator< float,long double >":
	return _npstat.FloatSampleAccumulator___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::SampleAccumulator< float,long double > &":
	return _npstat.FloatSampleAccumulator___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::SampleAccumulator< float,long double > &":
	return _npstat.FloatSampleAccumulator___idiv__(self, r)

	def cov(self, other: 'FloatSampleAccumulator') -> "long double":
	return _npstat.FloatSampleAccumulator_cov(self, other)

	def corr(self, other: 'FloatSampleAccumulator') -> "long double":
	return _npstat.FloatSampleAccumulator_corr(self, other)

	def accumulateAll(self, values: 'FloatVector') -> "void":
	return _npstat.FloatSampleAccumulator_accumulateAll(self, values)
	__swig_destroy__ = _npstat.delete_FloatSampleAccumulator
	__del__ = lambda self: None
	FloatSampleAccumulator_swigregister = _npstat.FloatSampleAccumulator_swigregister
	FloatSampleAccumulator_swigregister(FloatSampleAccumulator)

	def FloatSampleAccumulator_classname() -> "char const *":
	return _npstat.FloatSampleAccumulator_classname()
	FloatSampleAccumulator_classname = _npstat.FloatSampleAccumulator_classname

	def FloatSampleAccumulator_version() -> "unsigned int":
	return _npstat.FloatSampleAccumulator_version()
	FloatSampleAccumulator_version = _npstat.FloatSampleAccumulator_version

	def FloatSampleAccumulator_restore(id: 'ClassId', arg3: 'istream', acc: 'FloatSampleAccumulator') -> "void":
	return _npstat.FloatSampleAccumulator_restore(id, arg3, acc)
	FloatSampleAccumulator_restore = _npstat.FloatSampleAccumulator_restore

	class DoubleSampleAccumulator(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleSampleAccumulator, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleSampleAccumulator, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_DoubleSampleAccumulator()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def count(self) -> "unsigned long":
	return _npstat.DoubleSampleAccumulator_count(self)

	def min(self) -> "double":
	return _npstat.DoubleSampleAccumulator_min(self)

	def max(self) -> "double":
	return _npstat.DoubleSampleAccumulator_max(self)

	def mean(self) -> "long double":
	return _npstat.DoubleSampleAccumulator_mean(self)

	def stdev(self) -> "long double":
	return _npstat.DoubleSampleAccumulator_stdev(self)

	def meanUncertainty(self) -> "long double":
	return _npstat.DoubleSampleAccumulator_meanUncertainty(self)

	def median(self) -> "double":
	return _npstat.DoubleSampleAccumulator_median(self)

	def cdf(self, value: 'double') -> "double":
	return _npstat.DoubleSampleAccumulator_cdf(self, value)

	def nBelow(self, value: 'double') -> "unsigned long":
	return _npstat.DoubleSampleAccumulator_nBelow(self, value)

	def quantile(self, x: 'double') -> "double":
	return _npstat.DoubleSampleAccumulator_quantile(self, x)

	def location(self) -> "double":
	return _npstat.DoubleSampleAccumulator_location(self)

	def rangeDown(self) -> "double":
	return _npstat.DoubleSampleAccumulator_rangeDown(self)

	def rangeUp(self) -> "double":
	return _npstat.DoubleSampleAccumulator_rangeUp(self)

	def sigmaRange(self) -> "double":
	return _npstat.DoubleSampleAccumulator_sigmaRange(self)

	def noThrowMean(self, valueIfNoData: 'long double const &') -> "long double":
	return _npstat.DoubleSampleAccumulator_noThrowMean(self, valueIfNoData)

	def noThrowStdev(self, valueIfNoData: 'long double const &') -> "long double":
	return _npstat.DoubleSampleAccumulator_noThrowStdev(self, valueIfNoData)

	def noThrowMeanUncertainty(self, valueIfNoData: 'long double const &') -> "long double":
	return _npstat.DoubleSampleAccumulator_noThrowMeanUncertainty(self, valueIfNoData)

	def data(self) -> "double const *":
	return _npstat.DoubleSampleAccumulator_data(self)

	def __eq__(self, r: 'DoubleSampleAccumulator') -> "bool":
	return _npstat.DoubleSampleAccumulator___eq__(self, r)

	def __ne__(self, r: 'DoubleSampleAccumulator') -> "bool":
	return _npstat.DoubleSampleAccumulator___ne__(self, r)

	def accumulate(self, *args) -> "void":
	return _npstat.DoubleSampleAccumulator_accumulate(self, *args)

	def __iadd__(self, *args) -> "npstat::SampleAccumulator< double,long double > &":
	return _npstat.DoubleSampleAccumulator___iadd__(self, *args)

	def __add__(self, r: 'DoubleSampleAccumulator') -> "npstat::SampleAccumulator< double,long double >":
	return _npstat.DoubleSampleAccumulator___add__(self, r)

	def reset(self) -> "void":
	return _npstat.DoubleSampleAccumulator_reset(self)

	def reserve(self, n: 'unsigned long const') -> "void":
	return _npstat.DoubleSampleAccumulator_reserve(self, n)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleSampleAccumulator_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleSampleAccumulator_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleSampleAccumulator_classname)
	else:
	classname = _npstat.DoubleSampleAccumulator_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleSampleAccumulator_version)
	else:
	version = _npstat.DoubleSampleAccumulator_version
	if _newclass:
	restore = staticmethod(_npstat.DoubleSampleAccumulator_restore)
	else:
	restore = _npstat.DoubleSampleAccumulator_restore

	def __mul__(self, r: 'double const') -> "npstat::SampleAccumulator< double,long double >":
	return _npstat.DoubleSampleAccumulator___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::SampleAccumulator< double,long double >":
	return _npstat.DoubleSampleAccumulator___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::SampleAccumulator< double,long double > &":
	return _npstat.DoubleSampleAccumulator___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::SampleAccumulator< double,long double > &":
	return _npstat.DoubleSampleAccumulator___idiv__(self, r)

	def cov(self, other: 'DoubleSampleAccumulator') -> "long double":
	return _npstat.DoubleSampleAccumulator_cov(self, other)

	def corr(self, other: 'DoubleSampleAccumulator') -> "long double":
	return _npstat.DoubleSampleAccumulator_corr(self, other)

	def accumulateAll(self, values: 'DoubleVector') -> "void":
	return _npstat.DoubleSampleAccumulator_accumulateAll(self, values)
	__swig_destroy__ = _npstat.delete_DoubleSampleAccumulator
	__del__ = lambda self: None
	DoubleSampleAccumulator_swigregister = _npstat.DoubleSampleAccumulator_swigregister
	DoubleSampleAccumulator_swigregister(DoubleSampleAccumulator)

	def DoubleSampleAccumulator_classname() -> "char const *":
	return _npstat.DoubleSampleAccumulator_classname()
	DoubleSampleAccumulator_classname = _npstat.DoubleSampleAccumulator_classname

	def DoubleSampleAccumulator_version() -> "unsigned int":
	return _npstat.DoubleSampleAccumulator_version()
	DoubleSampleAccumulator_version = _npstat.DoubleSampleAccumulator_version

	def DoubleSampleAccumulator_restore(id: 'ClassId', arg3: 'istream', acc: 'DoubleSampleAccumulator') -> "void":
	return _npstat.DoubleSampleAccumulator_restore(id, arg3, acc)
	DoubleSampleAccumulator_restore = _npstat.DoubleSampleAccumulator_restore

	class ItemDescriptor(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, ItemDescriptor, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, ItemDescriptor, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_ItemDescriptor(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ItemDescriptor
	__del__ = lambda self: None

	def type(self) -> "gs::ClassId const &":
	return _npstat.ItemDescriptor_type(self)

	def ioPrototype(self) -> "std::string const &":
	return _npstat.ItemDescriptor_ioPrototype(self)

	def name(self) -> "std::string const &":
	return _npstat.ItemDescriptor_name(self)

	def category(self) -> "std::string const &":
	return _npstat.ItemDescriptor_category(self)

	def nameAndCategory(self) -> "std::pair< std::string,std::string > const &":
	return _npstat.ItemDescriptor_nameAndCategory(self)

	def __eq__(self, r: 'ItemDescriptor') -> "bool":
	return _npstat.ItemDescriptor___eq__(self, r)

	def __ne__(self, r: 'ItemDescriptor') -> "bool":
	return _npstat.ItemDescriptor___ne__(self, r)

	def isSameClassIdandIO(self, r: 'ItemDescriptor') -> "bool":
	return _npstat.ItemDescriptor_isSameClassIdandIO(self, r)

	def isSameIOPrototype(self, r: 'ItemDescriptor') -> "bool":
	return _npstat.ItemDescriptor_isSameIOPrototype(self, r)

	def getName(self) -> "std::string":
	return _npstat.ItemDescriptor_getName(self)

	def getCategory(self) -> "std::string":
	return _npstat.ItemDescriptor_getCategory(self)
	ItemDescriptor_swigregister = _npstat.ItemDescriptor_swigregister
	ItemDescriptor_swigregister(ItemDescriptor)

	class AbsRecord(ItemDescriptor):
	__swig_setmethods__ = {}
	for _s in [ItemDescriptor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsRecord, name, value)
	__swig_getmethods__ = {}
	for _s in [ItemDescriptor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, AbsRecord, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsRecord
	__del__ = lambda self: None

	def id(self) -> "unsigned long long":
	return _npstat.AbsRecord_id(self)

	def itemLength(self) -> "unsigned long long":
	return _npstat.AbsRecord_itemLength(self)
	AbsRecord_swigregister = _npstat.AbsRecord_swigregister
	AbsRecord_swigregister(AbsRecord)

	class SearchSpecifier(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, SearchSpecifier, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, SearchSpecifier, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_SearchSpecifier(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def useRegex(self) -> "bool":
	return _npstat.SearchSpecifier_useRegex(self)

	def pattern(self) -> "std::string const &":
	return _npstat.SearchSpecifier_pattern(self)

	def matches(self, sentence: 'string') -> "bool":
	return _npstat.SearchSpecifier_matches(self, sentence)

	def getPattern(self) -> "std::string":
	return _npstat.SearchSpecifier_getPattern(self)
	__swig_destroy__ = _npstat.delete_SearchSpecifier
	__del__ = lambda self: None
	SearchSpecifier_swigregister = _npstat.SearchSpecifier_swigregister
	SearchSpecifier_swigregister(SearchSpecifier)

	class AbsReference(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsReference, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, AbsReference, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsReference
	__del__ = lambda self: None

	def archive(self) -> "gs::AbsArchive &":
	return _npstat.AbsReference_archive(self)

	def type(self) -> "gs::ClassId const &":
	return _npstat.AbsReference_type(self)

	def ioPrototype(self) -> "std::string const &":
	return _npstat.AbsReference_ioPrototype(self)

	def namePattern(self) -> "gs::SearchSpecifier const &":
	return _npstat.AbsReference_namePattern(self)

	def categoryPattern(self) -> "gs::SearchSpecifier const &":
	return _npstat.AbsReference_categoryPattern(self)

	def isIOCompatible(self, r: 'CatalogEntry') -> "bool":
	return _npstat.AbsReference_isIOCompatible(self, r)

	def isSameIOPrototype(self, r: 'CatalogEntry') -> "bool":
	return _npstat.AbsReference_isSameIOPrototype(self, r)

	def empty(self) -> "bool":
	return _npstat.AbsReference_empty(self)

	def unique(self) -> "bool":
	return _npstat.AbsReference_unique(self)

	def size(self) -> "unsigned long":
	return _npstat.AbsReference_size(self)

	def id(self, index: 'unsigned long') -> "unsigned long long":
	return _npstat.AbsReference_id(self, index)

	def indexedCatalogEntry(self, index: 'unsigned long') -> "CPP11_shared_ptr< gs::CatalogEntry const >":
	return _npstat.AbsReference_indexedCatalogEntry(self, index)
	AbsReference_swigregister = _npstat.AbsReference_swigregister
	AbsReference_swigregister(AbsReference)


	def makeShape(*args) -> "npstat::ArrayShape":
	return _npstat.makeShape(*args)
	makeShape = _npstat.makeShape

	def doubleShape(inputShape: 'UIntVector') -> "npstat::ArrayShape":
	return _npstat.doubleShape(inputShape)
	doubleShape = _npstat.doubleShape

	def halfShape(inputShape: 'UIntVector') -> "npstat::ArrayShape":
	return _npstat.halfShape(inputShape)
	halfShape = _npstat.halfShape

	def isSubShape(sh1: 'UIntVector', sh2: 'UIntVector') -> "bool":
	return _npstat.isSubShape(sh1, sh2)
	isSubShape = _npstat.isSubShape
	class UCharInterval(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharInterval, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharInterval, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_UCharInterval(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def setMin(self, value: 'unsigned char const') -> "void":
	return _npstat.UCharInterval_setMin(self, value)

	def setMax(self, value: 'unsigned char const') -> "void":
	return _npstat.UCharInterval_setMax(self, value)

	def setBounds(self, minval: 'unsigned char const', maxval: 'unsigned char const', swapIfOutOfOrder: 'bool const'=False) -> "void":
	return _npstat.UCharInterval_setBounds(self, minval, maxval, swapIfOutOfOrder)

	def min(self) -> "unsigned char const":
	return _npstat.UCharInterval_min(self)

	def max(self) -> "unsigned char const":
	return _npstat.UCharInterval_max(self)

	def getBounds(self, pmin: 'unsigned char ', pmax: 'unsigned char ') -> "void":
	return _npstat.UCharInterval_getBounds(self, pmin, pmax)

	def length(self) -> "unsigned char":
	return _npstat.UCharInterval_length(self)

	def midpoint(self) -> "unsigned char":
	return _npstat.UCharInterval_midpoint(self)

	def isInsideLower(self, value: 'unsigned char const') -> "bool":
	return _npstat.UCharInterval_isInsideLower(self, value)

	def isInsideUpper(self, value: 'unsigned char const') -> "bool":
	return _npstat.UCharInterval_isInsideUpper(self, value)

	def isInsideWithBounds(self, value: 'unsigned char const') -> "bool":
	return _npstat.UCharInterval_isInsideWithBounds(self, value)

	def isInside(self, value: 'unsigned char const') -> "bool":
	return _npstat.UCharInterval_isInside(self, value)

	def __imul__(self, r: 'double') -> "npstat::Interval< unsigned char > &":
	return _npstat.UCharInterval___imul__(self, r)

	def __itruediv__(self, *args):
	return _npstat.UCharInterval___itruediv__(self, *args)
	__idiv__ = __itruediv__



	def __iadd__(self, value: 'unsigned char const') -> "npstat::Interval< unsigned char > &":
	return _npstat.UCharInterval___iadd__(self, value)

	def __isub__(self, value: 'unsigned char const') -> "npstat::Interval< unsigned char > &":
	return _npstat.UCharInterval___isub__(self, value)

	def moveMidpointTo0(self) -> "npstat::Interval< unsigned char > &":
	return _npstat.UCharInterval_moveMidpointTo0(self)

	def expand(self, r: 'double') -> "npstat::Interval< unsigned char > &":
	return _npstat.UCharInterval_expand(self, r)

	def overlap(self, r: 'UCharInterval') -> "npstat::Interval< unsigned char >":
	return _npstat.UCharInterval_overlap(self, r)

	def overlapLength(self, r: 'UCharInterval') -> "unsigned char":
	return _npstat.UCharInterval_overlapLength(self, r)

	def overlapFraction(self, r: 'UCharInterval') -> "double":
	return _npstat.UCharInterval_overlapFraction(self, r)

	def logicalDifference(self, r: 'UCharInterval') -> "std::pair< npstat::Interval< unsigned char >,npstat::Interval< unsigned char > >":
	return _npstat.UCharInterval_logicalDifference(self, r)
	__swig_destroy__ = _npstat.delete_UCharInterval
	__del__ = lambda self: None
	UCharInterval_swigregister = _npstat.UCharInterval_swigregister
	UCharInterval_swigregister(UCharInterval)

	class IntInterval(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntInterval, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntInterval, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_IntInterval(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def setMin(self, value: 'int const') -> "void":
	return _npstat.IntInterval_setMin(self, value)

	def setMax(self, value: 'int const') -> "void":
	return _npstat.IntInterval_setMax(self, value)

	def setBounds(self, minval: 'int const', maxval: 'int const', swapIfOutOfOrder: 'bool const'=False) -> "void":
	return _npstat.IntInterval_setBounds(self, minval, maxval, swapIfOutOfOrder)

	def min(self) -> "int const":
	return _npstat.IntInterval_min(self)

	def max(self) -> "int const":
	return _npstat.IntInterval_max(self)

	def getBounds(self, pmin: 'int ', pmax: 'int ') -> "void":
	return _npstat.IntInterval_getBounds(self, pmin, pmax)

	def length(self) -> "int":
	return _npstat.IntInterval_length(self)

	def midpoint(self) -> "int":
	return _npstat.IntInterval_midpoint(self)

	def isInsideLower(self, value: 'int const') -> "bool":
	return _npstat.IntInterval_isInsideLower(self, value)

	def isInsideUpper(self, value: 'int const') -> "bool":
	return _npstat.IntInterval_isInsideUpper(self, value)

	def isInsideWithBounds(self, value: 'int const') -> "bool":
	return _npstat.IntInterval_isInsideWithBounds(self, value)

	def isInside(self, value: 'int const') -> "bool":
	return _npstat.IntInterval_isInside(self, value)

	def __imul__(self, r: 'double') -> "npstat::Interval< int > &":
	return _npstat.IntInterval___imul__(self, r)

	def __itruediv__(self, *args):
	return _npstat.IntInterval___itruediv__(self, *args)
	__idiv__ = __itruediv__



	def __iadd__(self, value: 'int const') -> "npstat::Interval< int > &":
	return _npstat.IntInterval___iadd__(self, value)

	def __isub__(self, value: 'int const') -> "npstat::Interval< int > &":
	return _npstat.IntInterval___isub__(self, value)

	def moveMidpointTo0(self) -> "npstat::Interval< int > &":
	return _npstat.IntInterval_moveMidpointTo0(self)

	def expand(self, r: 'double') -> "npstat::Interval< int > &":
	return _npstat.IntInterval_expand(self, r)

	def overlap(self, r: 'IntInterval') -> "npstat::Interval< int >":
	return _npstat.IntInterval_overlap(self, r)

	def overlapLength(self, r: 'IntInterval') -> "int":
	return _npstat.IntInterval_overlapLength(self, r)

	def overlapFraction(self, r: 'IntInterval') -> "double":
	return _npstat.IntInterval_overlapFraction(self, r)

	def logicalDifference(self, r: 'IntInterval') -> "std::pair< npstat::Interval< int >,npstat::Interval< int > >":
	return _npstat.IntInterval_logicalDifference(self, r)
	__swig_destroy__ = _npstat.delete_IntInterval
	__del__ = lambda self: None
	IntInterval_swigregister = _npstat.IntInterval_swigregister
	IntInterval_swigregister(IntInterval)

	class LLongInterval(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongInterval, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongInterval, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_LLongInterval(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def setMin(self, value: 'long long const') -> "void":
	return _npstat.LLongInterval_setMin(self, value)

	def setMax(self, value: 'long long const') -> "void":
	return _npstat.LLongInterval_setMax(self, value)

	def setBounds(self, minval: 'long long const', maxval: 'long long const', swapIfOutOfOrder: 'bool const'=False) -> "void":
	return _npstat.LLongInterval_setBounds(self, minval, maxval, swapIfOutOfOrder)

	def min(self) -> "long long const":
	return _npstat.LLongInterval_min(self)

	def max(self) -> "long long const":
	return _npstat.LLongInterval_max(self)

	def getBounds(self, pmin: 'long long ', pmax: 'long long ') -> "void":
	return _npstat.LLongInterval_getBounds(self, pmin, pmax)

	def length(self) -> "long long":
	return _npstat.LLongInterval_length(self)

	def midpoint(self) -> "long long":
	return _npstat.LLongInterval_midpoint(self)

	def isInsideLower(self, value: 'long long const') -> "bool":
	return _npstat.LLongInterval_isInsideLower(self, value)

	def isInsideUpper(self, value: 'long long const') -> "bool":
	return _npstat.LLongInterval_isInsideUpper(self, value)

	def isInsideWithBounds(self, value: 'long long const') -> "bool":
	return _npstat.LLongInterval_isInsideWithBounds(self, value)

	def isInside(self, value: 'long long const') -> "bool":
	return _npstat.LLongInterval_isInside(self, value)

	def __imul__(self, r: 'double') -> "npstat::Interval< long long > &":
	return _npstat.LLongInterval___imul__(self, r)

	def __itruediv__(self, *args):
	return _npstat.LLongInterval___itruediv__(self, *args)
	__idiv__ = __itruediv__



	def __iadd__(self, value: 'long long const') -> "npstat::Interval< long long > &":
	return _npstat.LLongInterval___iadd__(self, value)

	def __isub__(self, value: 'long long const') -> "npstat::Interval< long long > &":
	return _npstat.LLongInterval___isub__(self, value)

	def moveMidpointTo0(self) -> "npstat::Interval< long long > &":
	return _npstat.LLongInterval_moveMidpointTo0(self)

	def expand(self, r: 'double') -> "npstat::Interval< long long > &":
	return _npstat.LLongInterval_expand(self, r)

	def overlap(self, r: 'LLongInterval') -> "npstat::Interval< long long >":
	return _npstat.LLongInterval_overlap(self, r)

	def overlapLength(self, r: 'LLongInterval') -> "long long":
	return _npstat.LLongInterval_overlapLength(self, r)

	def overlapFraction(self, r: 'LLongInterval') -> "double":
	return _npstat.LLongInterval_overlapFraction(self, r)

	def logicalDifference(self, r: 'LLongInterval') -> "std::pair< npstat::Interval< long long >,npstat::Interval< long long > >":
	return _npstat.LLongInterval_logicalDifference(self, r)
	__swig_destroy__ = _npstat.delete_LLongInterval
	__del__ = lambda self: None
	LLongInterval_swigregister = _npstat.LLongInterval_swigregister
	LLongInterval_swigregister(LLongInterval)

	class FloatInterval(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatInterval, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatInterval, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_FloatInterval(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def setMin(self, value: 'float const') -> "void":
	return _npstat.FloatInterval_setMin(self, value)

	def setMax(self, value: 'float const') -> "void":
	return _npstat.FloatInterval_setMax(self, value)

	def setBounds(self, minval: 'float const', maxval: 'float const', swapIfOutOfOrder: 'bool const'=False) -> "void":
	return _npstat.FloatInterval_setBounds(self, minval, maxval, swapIfOutOfOrder)

	def min(self) -> "float const":
	return _npstat.FloatInterval_min(self)

	def max(self) -> "float const":
	return _npstat.FloatInterval_max(self)

	def getBounds(self, pmin: 'float ', pmax: 'float ') -> "void":
	return _npstat.FloatInterval_getBounds(self, pmin, pmax)

	def length(self) -> "float":
	return _npstat.FloatInterval_length(self)

	def midpoint(self) -> "float":
	return _npstat.FloatInterval_midpoint(self)

	def isInsideLower(self, value: 'float const') -> "bool":
	return _npstat.FloatInterval_isInsideLower(self, value)

	def isInsideUpper(self, value: 'float const') -> "bool":
	return _npstat.FloatInterval_isInsideUpper(self, value)

	def isInsideWithBounds(self, value: 'float const') -> "bool":
	return _npstat.FloatInterval_isInsideWithBounds(self, value)

	def isInside(self, value: 'float const') -> "bool":
	return _npstat.FloatInterval_isInside(self, value)

	def __imul__(self, r: 'double') -> "npstat::Interval< float > &":
	return _npstat.FloatInterval___imul__(self, r)

	def __itruediv__(self, *args):
	return _npstat.FloatInterval___itruediv__(self, *args)
	__idiv__ = __itruediv__



	def __iadd__(self, value: 'float const') -> "npstat::Interval< float > &":
	return _npstat.FloatInterval___iadd__(self, value)

	def __isub__(self, value: 'float const') -> "npstat::Interval< float > &":
	return _npstat.FloatInterval___isub__(self, value)

	def moveMidpointTo0(self) -> "npstat::Interval< float > &":
	return _npstat.FloatInterval_moveMidpointTo0(self)

	def expand(self, r: 'double') -> "npstat::Interval< float > &":
	return _npstat.FloatInterval_expand(self, r)

	def overlap(self, r: 'FloatInterval') -> "npstat::Interval< float >":
	return _npstat.FloatInterval_overlap(self, r)

	def overlapLength(self, r: 'FloatInterval') -> "float":
	return _npstat.FloatInterval_overlapLength(self, r)

	def overlapFraction(self, r: 'FloatInterval') -> "double":
	return _npstat.FloatInterval_overlapFraction(self, r)

	def logicalDifference(self, r: 'FloatInterval') -> "std::pair< npstat::Interval< float >,npstat::Interval< float > >":
	return _npstat.FloatInterval_logicalDifference(self, r)
	__swig_destroy__ = _npstat.delete_FloatInterval
	__del__ = lambda self: None
	FloatInterval_swigregister = _npstat.FloatInterval_swigregister
	FloatInterval_swigregister(FloatInterval)

	class DoubleInterval(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleInterval, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleInterval, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_DoubleInterval(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def setMin(self, value: 'double const') -> "void":
	return _npstat.DoubleInterval_setMin(self, value)

	def setMax(self, value: 'double const') -> "void":
	return _npstat.DoubleInterval_setMax(self, value)

	def setBounds(self, minval: 'double const', maxval: 'double const', swapIfOutOfOrder: 'bool const'=False) -> "void":
	return _npstat.DoubleInterval_setBounds(self, minval, maxval, swapIfOutOfOrder)

	def min(self) -> "double const":
	return _npstat.DoubleInterval_min(self)

	def max(self) -> "double const":
	return _npstat.DoubleInterval_max(self)

	def getBounds(self, pmin: 'double ', pmax: 'double ') -> "void":
	return _npstat.DoubleInterval_getBounds(self, pmin, pmax)

	def length(self) -> "double":
	return _npstat.DoubleInterval_length(self)

	def midpoint(self) -> "double":
	return _npstat.DoubleInterval_midpoint(self)

	def isInsideLower(self, value: 'double const') -> "bool":
	return _npstat.DoubleInterval_isInsideLower(self, value)

	def isInsideUpper(self, value: 'double const') -> "bool":
	return _npstat.DoubleInterval_isInsideUpper(self, value)

	def isInsideWithBounds(self, value: 'double const') -> "bool":
	return _npstat.DoubleInterval_isInsideWithBounds(self, value)

	def isInside(self, value: 'double const') -> "bool":
	return _npstat.DoubleInterval_isInside(self, value)

	def __imul__(self, r: 'double') -> "npstat::Interval< double > &":
	return _npstat.DoubleInterval___imul__(self, r)

	def __itruediv__(self, *args):
	return _npstat.DoubleInterval___itruediv__(self, *args)
	__idiv__ = __itruediv__



	def __iadd__(self, value: 'double const') -> "npstat::Interval< double > &":
	return _npstat.DoubleInterval___iadd__(self, value)

	def __isub__(self, value: 'double const') -> "npstat::Interval< double > &":
	return _npstat.DoubleInterval___isub__(self, value)

	def moveMidpointTo0(self) -> "npstat::Interval< double > &":
	return _npstat.DoubleInterval_moveMidpointTo0(self)

	def expand(self, r: 'double') -> "npstat::Interval< double > &":
	return _npstat.DoubleInterval_expand(self, r)

	def overlap(self, r: 'DoubleInterval') -> "npstat::Interval< double >":
	return _npstat.DoubleInterval_overlap(self, r)

	def overlapLength(self, r: 'DoubleInterval') -> "double":
	return _npstat.DoubleInterval_overlapLength(self, r)

	def overlapFraction(self, r: 'DoubleInterval') -> "double":
	return _npstat.DoubleInterval_overlapFraction(self, r)

	def logicalDifference(self, r: 'DoubleInterval') -> "std::pair< npstat::Interval< double >,npstat::Interval< double > >":
	return _npstat.DoubleInterval_logicalDifference(self, r)
	__swig_destroy__ = _npstat.delete_DoubleInterval
	__del__ = lambda self: None
	DoubleInterval_swigregister = _npstat.DoubleInterval_swigregister
	DoubleInterval_swigregister(DoubleInterval)

	class UIntInterval(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UIntInterval, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UIntInterval, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_UIntInterval(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def setMin(self, value: 'unsigned int const') -> "void":
	return _npstat.UIntInterval_setMin(self, value)

	def setMax(self, value: 'unsigned int const') -> "void":
	return _npstat.UIntInterval_setMax(self, value)

	def setBounds(self, minval: 'unsigned int const', maxval: 'unsigned int const', swapIfOutOfOrder: 'bool const'=False) -> "void":
	return _npstat.UIntInterval_setBounds(self, minval, maxval, swapIfOutOfOrder)

	def min(self) -> "unsigned int const":
	return _npstat.UIntInterval_min(self)

	def max(self) -> "unsigned int const":
	return _npstat.UIntInterval_max(self)

	def getBounds(self, pmin: 'unsigned int ', pmax: 'unsigned int ') -> "void":
	return _npstat.UIntInterval_getBounds(self, pmin, pmax)

	def length(self) -> "unsigned int":
	return _npstat.UIntInterval_length(self)

	def midpoint(self) -> "unsigned int":
	return _npstat.UIntInterval_midpoint(self)

	def isInsideLower(self, value: 'unsigned int const') -> "bool":
	return _npstat.UIntInterval_isInsideLower(self, value)

	def isInsideUpper(self, value: 'unsigned int const') -> "bool":
	return _npstat.UIntInterval_isInsideUpper(self, value)

	def isInsideWithBounds(self, value: 'unsigned int const') -> "bool":
	return _npstat.UIntInterval_isInsideWithBounds(self, value)

	def isInside(self, value: 'unsigned int const') -> "bool":
	return _npstat.UIntInterval_isInside(self, value)

	def __imul__(self, r: 'double') -> "npstat::Interval< unsigned int > &":
	return _npstat.UIntInterval___imul__(self, r)

	def __itruediv__(self, *args):
	return _npstat.UIntInterval___itruediv__(self, *args)
	__idiv__ = __itruediv__



	def __iadd__(self, value: 'unsigned int const') -> "npstat::Interval< unsigned int > &":
	return _npstat.UIntInterval___iadd__(self, value)

	def __isub__(self, value: 'unsigned int const') -> "npstat::Interval< unsigned int > &":
	return _npstat.UIntInterval___isub__(self, value)

	def moveMidpointTo0(self) -> "npstat::Interval< unsigned int > &":
	return _npstat.UIntInterval_moveMidpointTo0(self)

	def expand(self, r: 'double') -> "npstat::Interval< unsigned int > &":
	return _npstat.UIntInterval_expand(self, r)

	def overlap(self, r: 'UIntInterval') -> "npstat::Interval< unsigned int >":
	return _npstat.UIntInterval_overlap(self, r)

	def overlapLength(self, r: 'UIntInterval') -> "unsigned int":
	return _npstat.UIntInterval_overlapLength(self, r)

	def overlapFraction(self, r: 'UIntInterval') -> "double":
	return _npstat.UIntInterval_overlapFraction(self, r)

	def logicalDifference(self, r: 'UIntInterval') -> "std::pair< npstat::Interval< unsigned int >,npstat::Interval< unsigned int > >":
	return _npstat.UIntInterval_logicalDifference(self, r)
	__swig_destroy__ = _npstat.delete_UIntInterval
	__del__ = lambda self: None
	UIntInterval_swigregister = _npstat.UIntInterval_swigregister
	UIntInterval_swigregister(UIntInterval)

	class IntIntervalVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntIntervalVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntIntervalVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.IntIntervalVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.IntIntervalVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.IntIntervalVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::Interval< int > >::size_type":
	return _npstat.IntIntervalVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::Interval< int > >::difference_type', j: 'std::vector< npstat::Interval< int > >::difference_type') -> "std::vector< npstat::Interval< int >,std::allocator< npstat::Interval< int > > > *":
	return _npstat.IntIntervalVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.IntIntervalVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::Interval< int > >::difference_type', j: 'std::vector< npstat::Interval< int > >::difference_type') -> "void":
	return _npstat.IntIntervalVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.IntIntervalVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::Interval< int > >::value_type const &":
	return _npstat.IntIntervalVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.IntIntervalVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::Interval< int > >::value_type":
	return _npstat.IntIntervalVector_pop(self)

	def append(self, x: 'IntInterval') -> "void":
	return _npstat.IntIntervalVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.IntIntervalVector_empty(self)

	def size(self) -> "std::vector< npstat::Interval< int > >::size_type":
	return _npstat.IntIntervalVector_size(self)

	def swap(self, v: 'IntIntervalVector') -> "void":
	return _npstat.IntIntervalVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::Interval< int > >::iterator":
	return _npstat.IntIntervalVector_begin(self)

	def end(self) -> "std::vector< npstat::Interval< int > >::iterator":
	return _npstat.IntIntervalVector_end(self)

	def rbegin(self) -> "std::vector< npstat::Interval< int > >::reverse_iterator":
	return _npstat.IntIntervalVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::Interval< int > >::reverse_iterator":
	return _npstat.IntIntervalVector_rend(self)

	def clear(self) -> "void":
	return _npstat.IntIntervalVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::Interval< int > >::allocator_type":
	return _npstat.IntIntervalVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.IntIntervalVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::Interval< int > >::iterator":
	return _npstat.IntIntervalVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_IntIntervalVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'IntInterval') -> "void":
	return _npstat.IntIntervalVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::Interval< int > >::value_type const &":
	return _npstat.IntIntervalVector_front(self)

	def back(self) -> "std::vector< npstat::Interval< int > >::value_type const &":
	return _npstat.IntIntervalVector_back(self)

	def assign(self, n: 'std::vector< npstat::Interval< int > >::size_type', x: 'IntInterval') -> "void":
	return _npstat.IntIntervalVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.IntIntervalVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.IntIntervalVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::Interval< int > >::size_type') -> "void":
	return _npstat.IntIntervalVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::Interval< int > >::size_type":
	return _npstat.IntIntervalVector_capacity(self)
	__swig_destroy__ = _npstat.delete_IntIntervalVector
	__del__ = lambda self: None
	IntIntervalVector_swigregister = _npstat.IntIntervalVector_swigregister
	IntIntervalVector_swigregister(IntIntervalVector)

	class UIntIntervalVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UIntIntervalVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UIntIntervalVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.UIntIntervalVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.UIntIntervalVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.UIntIntervalVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::Interval< unsigned int > >::size_type":
	return _npstat.UIntIntervalVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::Interval< unsigned int > >::difference_type', j: 'std::vector< npstat::Interval< unsigned int > >::difference_type') -> "std::vector< npstat::Interval< unsigned int >,std::allocator< npstat::Interval< unsigned int > > > *":
	return _npstat.UIntIntervalVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.UIntIntervalVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::Interval< unsigned int > >::difference_type', j: 'std::vector< npstat::Interval< unsigned int > >::difference_type') -> "void":
	return _npstat.UIntIntervalVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.UIntIntervalVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::Interval< unsigned int > >::value_type const &":
	return _npstat.UIntIntervalVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.UIntIntervalVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::Interval< unsigned int > >::value_type":
	return _npstat.UIntIntervalVector_pop(self)

	def append(self, x: 'UIntInterval') -> "void":
	return _npstat.UIntIntervalVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.UIntIntervalVector_empty(self)

	def size(self) -> "std::vector< npstat::Interval< unsigned int > >::size_type":
	return _npstat.UIntIntervalVector_size(self)

	def swap(self, v: 'UIntIntervalVector') -> "void":
	return _npstat.UIntIntervalVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::Interval< unsigned int > >::iterator":
	return _npstat.UIntIntervalVector_begin(self)

	def end(self) -> "std::vector< npstat::Interval< unsigned int > >::iterator":
	return _npstat.UIntIntervalVector_end(self)

	def rbegin(self) -> "std::vector< npstat::Interval< unsigned int > >::reverse_iterator":
	return _npstat.UIntIntervalVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::Interval< unsigned int > >::reverse_iterator":
	return _npstat.UIntIntervalVector_rend(self)

	def clear(self) -> "void":
	return _npstat.UIntIntervalVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::Interval< unsigned int > >::allocator_type":
	return _npstat.UIntIntervalVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.UIntIntervalVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::Interval< unsigned int > >::iterator":
	return _npstat.UIntIntervalVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_UIntIntervalVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'UIntInterval') -> "void":
	return _npstat.UIntIntervalVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::Interval< unsigned int > >::value_type const &":
	return _npstat.UIntIntervalVector_front(self)

	def back(self) -> "std::vector< npstat::Interval< unsigned int > >::value_type const &":
	return _npstat.UIntIntervalVector_back(self)

	def assign(self, n: 'std::vector< npstat::Interval< unsigned int > >::size_type', x: 'UIntInterval') -> "void":
	return _npstat.UIntIntervalVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.UIntIntervalVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.UIntIntervalVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::Interval< unsigned int > >::size_type') -> "void":
	return _npstat.UIntIntervalVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::Interval< unsigned int > >::size_type":
	return _npstat.UIntIntervalVector_capacity(self)
	__swig_destroy__ = _npstat.delete_UIntIntervalVector
	__del__ = lambda self: None
	UIntIntervalVector_swigregister = _npstat.UIntIntervalVector_swigregister
	UIntIntervalVector_swigregister(UIntIntervalVector)

	class LLongIntervalVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongIntervalVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongIntervalVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.LLongIntervalVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.LLongIntervalVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.LLongIntervalVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::Interval< long long > >::size_type":
	return _npstat.LLongIntervalVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::Interval< long long > >::difference_type', j: 'std::vector< npstat::Interval< long long > >::difference_type') -> "std::vector< npstat::Interval< long long >,std::allocator< npstat::Interval< long long > > > *":
	return _npstat.LLongIntervalVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.LLongIntervalVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::Interval< long long > >::difference_type', j: 'std::vector< npstat::Interval< long long > >::difference_type') -> "void":
	return _npstat.LLongIntervalVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.LLongIntervalVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::Interval< long long > >::value_type const &":
	return _npstat.LLongIntervalVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.LLongIntervalVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::Interval< long long > >::value_type":
	return _npstat.LLongIntervalVector_pop(self)

	def append(self, x: 'LLongInterval') -> "void":
	return _npstat.LLongIntervalVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.LLongIntervalVector_empty(self)

	def size(self) -> "std::vector< npstat::Interval< long long > >::size_type":
	return _npstat.LLongIntervalVector_size(self)

	def swap(self, v: 'LLongIntervalVector') -> "void":
	return _npstat.LLongIntervalVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::Interval< long long > >::iterator":
	return _npstat.LLongIntervalVector_begin(self)

	def end(self) -> "std::vector< npstat::Interval< long long > >::iterator":
	return _npstat.LLongIntervalVector_end(self)

	def rbegin(self) -> "std::vector< npstat::Interval< long long > >::reverse_iterator":
	return _npstat.LLongIntervalVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::Interval< long long > >::reverse_iterator":
	return _npstat.LLongIntervalVector_rend(self)

	def clear(self) -> "void":
	return _npstat.LLongIntervalVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::Interval< long long > >::allocator_type":
	return _npstat.LLongIntervalVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.LLongIntervalVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::Interval< long long > >::iterator":
	return _npstat.LLongIntervalVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_LLongIntervalVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'LLongInterval') -> "void":
	return _npstat.LLongIntervalVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::Interval< long long > >::value_type const &":
	return _npstat.LLongIntervalVector_front(self)

	def back(self) -> "std::vector< npstat::Interval< long long > >::value_type const &":
	return _npstat.LLongIntervalVector_back(self)

	def assign(self, n: 'std::vector< npstat::Interval< long long > >::size_type', x: 'LLongInterval') -> "void":
	return _npstat.LLongIntervalVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.LLongIntervalVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.LLongIntervalVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::Interval< long long > >::size_type') -> "void":
	return _npstat.LLongIntervalVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::Interval< long long > >::size_type":
	return _npstat.LLongIntervalVector_capacity(self)
	__swig_destroy__ = _npstat.delete_LLongIntervalVector
	__del__ = lambda self: None
	LLongIntervalVector_swigregister = _npstat.LLongIntervalVector_swigregister
	LLongIntervalVector_swigregister(LLongIntervalVector)

	class FloatIntervalVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatIntervalVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatIntervalVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.FloatIntervalVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.FloatIntervalVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.FloatIntervalVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::Interval< float > >::size_type":
	return _npstat.FloatIntervalVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::Interval< float > >::difference_type', j: 'std::vector< npstat::Interval< float > >::difference_type') -> "std::vector< npstat::Interval< float >,std::allocator< npstat::Interval< float > > > *":
	return _npstat.FloatIntervalVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.FloatIntervalVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::Interval< float > >::difference_type', j: 'std::vector< npstat::Interval< float > >::difference_type') -> "void":
	return _npstat.FloatIntervalVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.FloatIntervalVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::Interval< float > >::value_type const &":
	return _npstat.FloatIntervalVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.FloatIntervalVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::Interval< float > >::value_type":
	return _npstat.FloatIntervalVector_pop(self)

	def append(self, x: 'FloatInterval') -> "void":
	return _npstat.FloatIntervalVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.FloatIntervalVector_empty(self)

	def size(self) -> "std::vector< npstat::Interval< float > >::size_type":
	return _npstat.FloatIntervalVector_size(self)

	def swap(self, v: 'FloatIntervalVector') -> "void":
	return _npstat.FloatIntervalVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::Interval< float > >::iterator":
	return _npstat.FloatIntervalVector_begin(self)

	def end(self) -> "std::vector< npstat::Interval< float > >::iterator":
	return _npstat.FloatIntervalVector_end(self)

	def rbegin(self) -> "std::vector< npstat::Interval< float > >::reverse_iterator":
	return _npstat.FloatIntervalVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::Interval< float > >::reverse_iterator":
	return _npstat.FloatIntervalVector_rend(self)

	def clear(self) -> "void":
	return _npstat.FloatIntervalVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::Interval< float > >::allocator_type":
	return _npstat.FloatIntervalVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.FloatIntervalVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::Interval< float > >::iterator":
	return _npstat.FloatIntervalVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_FloatIntervalVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'FloatInterval') -> "void":
	return _npstat.FloatIntervalVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::Interval< float > >::value_type const &":
	return _npstat.FloatIntervalVector_front(self)

	def back(self) -> "std::vector< npstat::Interval< float > >::value_type const &":
	return _npstat.FloatIntervalVector_back(self)

	def assign(self, n: 'std::vector< npstat::Interval< float > >::size_type', x: 'FloatInterval') -> "void":
	return _npstat.FloatIntervalVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.FloatIntervalVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.FloatIntervalVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::Interval< float > >::size_type') -> "void":
	return _npstat.FloatIntervalVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::Interval< float > >::size_type":
	return _npstat.FloatIntervalVector_capacity(self)
	__swig_destroy__ = _npstat.delete_FloatIntervalVector
	__del__ = lambda self: None
	FloatIntervalVector_swigregister = _npstat.FloatIntervalVector_swigregister
	FloatIntervalVector_swigregister(FloatIntervalVector)

	class DoubleIntervalVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleIntervalVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleIntervalVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.DoubleIntervalVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.DoubleIntervalVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.DoubleIntervalVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::Interval< double > >::size_type":
	return _npstat.DoubleIntervalVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::Interval< double > >::difference_type', j: 'std::vector< npstat::Interval< double > >::difference_type') -> "std::vector< npstat::Interval< double >,std::allocator< npstat::Interval< double > > > *":
	return _npstat.DoubleIntervalVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.DoubleIntervalVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::Interval< double > >::difference_type', j: 'std::vector< npstat::Interval< double > >::difference_type') -> "void":
	return _npstat.DoubleIntervalVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.DoubleIntervalVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::Interval< double > >::value_type const &":
	return _npstat.DoubleIntervalVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.DoubleIntervalVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::Interval< double > >::value_type":
	return _npstat.DoubleIntervalVector_pop(self)

	def append(self, x: 'DoubleInterval') -> "void":
	return _npstat.DoubleIntervalVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.DoubleIntervalVector_empty(self)

	def size(self) -> "std::vector< npstat::Interval< double > >::size_type":
	return _npstat.DoubleIntervalVector_size(self)

	def swap(self, v: 'DoubleIntervalVector') -> "void":
	return _npstat.DoubleIntervalVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::Interval< double > >::iterator":
	return _npstat.DoubleIntervalVector_begin(self)

	def end(self) -> "std::vector< npstat::Interval< double > >::iterator":
	return _npstat.DoubleIntervalVector_end(self)

	def rbegin(self) -> "std::vector< npstat::Interval< double > >::reverse_iterator":
	return _npstat.DoubleIntervalVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::Interval< double > >::reverse_iterator":
	return _npstat.DoubleIntervalVector_rend(self)

	def clear(self) -> "void":
	return _npstat.DoubleIntervalVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::Interval< double > >::allocator_type":
	return _npstat.DoubleIntervalVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.DoubleIntervalVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::Interval< double > >::iterator":
	return _npstat.DoubleIntervalVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_DoubleIntervalVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'DoubleInterval') -> "void":
	return _npstat.DoubleIntervalVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::Interval< double > >::value_type const &":
	return _npstat.DoubleIntervalVector_front(self)

	def back(self) -> "std::vector< npstat::Interval< double > >::value_type const &":
	return _npstat.DoubleIntervalVector_back(self)

	def assign(self, n: 'std::vector< npstat::Interval< double > >::size_type', x: 'DoubleInterval') -> "void":
	return _npstat.DoubleIntervalVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.DoubleIntervalVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.DoubleIntervalVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::Interval< double > >::size_type') -> "void":
	return _npstat.DoubleIntervalVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::Interval< double > >::size_type":
	return _npstat.DoubleIntervalVector_capacity(self)
	__swig_destroy__ = _npstat.delete_DoubleIntervalVector
	__del__ = lambda self: None
	DoubleIntervalVector_swigregister = _npstat.DoubleIntervalVector_swigregister
	DoubleIntervalVector_swigregister(DoubleIntervalVector)

	class UCharIntervalVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharIntervalVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharIntervalVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.UCharIntervalVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.UCharIntervalVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.UCharIntervalVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::Interval< unsigned char > >::size_type":
	return _npstat.UCharIntervalVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::Interval< unsigned char > >::difference_type', j: 'std::vector< npstat::Interval< unsigned char > >::difference_type') -> "std::vector< npstat::Interval< unsigned char >,std::allocator< npstat::Interval< unsigned char > > > *":
	return _npstat.UCharIntervalVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.UCharIntervalVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::Interval< unsigned char > >::difference_type', j: 'std::vector< npstat::Interval< unsigned char > >::difference_type') -> "void":
	return _npstat.UCharIntervalVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.UCharIntervalVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::Interval< unsigned char > >::value_type const &":
	return _npstat.UCharIntervalVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.UCharIntervalVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::Interval< unsigned char > >::value_type":
	return _npstat.UCharIntervalVector_pop(self)

	def append(self, x: 'UCharInterval') -> "void":
	return _npstat.UCharIntervalVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.UCharIntervalVector_empty(self)

	def size(self) -> "std::vector< npstat::Interval< unsigned char > >::size_type":
	return _npstat.UCharIntervalVector_size(self)

	def swap(self, v: 'UCharIntervalVector') -> "void":
	return _npstat.UCharIntervalVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::Interval< unsigned char > >::iterator":
	return _npstat.UCharIntervalVector_begin(self)

	def end(self) -> "std::vector< npstat::Interval< unsigned char > >::iterator":
	return _npstat.UCharIntervalVector_end(self)

	def rbegin(self) -> "std::vector< npstat::Interval< unsigned char > >::reverse_iterator":
	return _npstat.UCharIntervalVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::Interval< unsigned char > >::reverse_iterator":
	return _npstat.UCharIntervalVector_rend(self)

	def clear(self) -> "void":
	return _npstat.UCharIntervalVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::Interval< unsigned char > >::allocator_type":
	return _npstat.UCharIntervalVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.UCharIntervalVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::Interval< unsigned char > >::iterator":
	return _npstat.UCharIntervalVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_UCharIntervalVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'UCharInterval') -> "void":
	return _npstat.UCharIntervalVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::Interval< unsigned char > >::value_type const &":
	return _npstat.UCharIntervalVector_front(self)

	def back(self) -> "std::vector< npstat::Interval< unsigned char > >::value_type const &":
	return _npstat.UCharIntervalVector_back(self)

	def assign(self, n: 'std::vector< npstat::Interval< unsigned char > >::size_type', x: 'UCharInterval') -> "void":
	return _npstat.UCharIntervalVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.UCharIntervalVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.UCharIntervalVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::Interval< unsigned char > >::size_type') -> "void":
	return _npstat.UCharIntervalVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::Interval< unsigned char > >::size_type":
	return _npstat.UCharIntervalVector_capacity(self)
	__swig_destroy__ = _npstat.delete_UCharIntervalVector
	__del__ = lambda self: None
	UCharIntervalVector_swigregister = _npstat.UCharIntervalVector_swigregister
	UCharIntervalVector_swigregister(UCharIntervalVector)

	class UCharBoxND(UCharIntervalVector):
	__swig_setmethods__ = {}
	for _s in [UCharIntervalVector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [UCharIntervalVector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UCharBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_UCharBoxND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned long":
	return _npstat.UCharBoxND_dim(self)

	def volume(self) -> "unsigned char":
	return _npstat.UCharBoxND_volume(self)

	def getMidpoint(self, coord: 'unsigned char *', coordLen: 'unsigned long') -> "void":
	return _npstat.UCharBoxND_getMidpoint(self, coord, coordLen)

	def __imul__(self, *args) -> "npstat::BoxND< unsigned char > &":
	return _npstat.UCharBoxND___imul__(self, *args)

	def __itruediv__(self, *args):
	return _npstat.UCharBoxND___itruediv__(self, *args)
	__idiv__ = __itruediv__



	def expand(self, *args) -> "npstat::BoxND< unsigned char > &":
	return _npstat.UCharBoxND_expand(self, *args)

	def moveToOrigin(self) -> "npstat::BoxND< unsigned char > &":
	return _npstat.UCharBoxND_moveToOrigin(self)

	def overlapVolume(self, r: 'UCharBoxND') -> "unsigned char":
	return _npstat.UCharBoxND_overlapVolume(self, r)

	def overlapFraction(self, r: 'UCharBoxND') -> "double":
	return _npstat.UCharBoxND_overlapFraction(self, r)
	if _newclass:
	unitBox = staticmethod(_npstat.UCharBoxND_unitBox)
	else:
	unitBox = _npstat.UCharBoxND_unitBox
	if _newclass:
	sizeTwoBox = staticmethod(_npstat.UCharBoxND_sizeTwoBox)
	else:
	sizeTwoBox = _npstat.UCharBoxND_sizeTwoBox
	if _newclass:
	allSpace = staticmethod(_npstat.UCharBoxND_allSpace)
	else:
	allSpace = _npstat.UCharBoxND_allSpace

	def classId(self) -> "gs::ClassId":
	return _npstat.UCharBoxND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.UCharBoxND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.UCharBoxND_classname)
	else:
	classname = _npstat.UCharBoxND_classname
	if _newclass:
	version = staticmethod(_npstat.UCharBoxND_version)
	else:
	version = _npstat.UCharBoxND_version
	if _newclass:
	restore = staticmethod(_npstat.UCharBoxND_restore)
	else:
	restore = _npstat.UCharBoxND_restore
	__swig_destroy__ = _npstat.delete_UCharBoxND
	__del__ = lambda self: None
	UCharBoxND_swigregister = _npstat.UCharBoxND_swigregister
	UCharBoxND_swigregister(UCharBoxND)

	def UCharBoxND_unitBox(ndim: 'unsigned long') -> "npstat::BoxND< unsigned char >":
	return _npstat.UCharBoxND_unitBox(ndim)
	UCharBoxND_unitBox = _npstat.UCharBoxND_unitBox

	def UCharBoxND_sizeTwoBox(ndim: 'unsigned long') -> "npstat::BoxND< unsigned char >":
	return _npstat.UCharBoxND_sizeTwoBox(ndim)
	UCharBoxND_sizeTwoBox = _npstat.UCharBoxND_sizeTwoBox

	def UCharBoxND_allSpace(ndim: 'unsigned long') -> "npstat::BoxND< unsigned char >":
	return _npstat.UCharBoxND_allSpace(ndim)
	UCharBoxND_allSpace = _npstat.UCharBoxND_allSpace

	def UCharBoxND_classname() -> "char const *":
	return _npstat.UCharBoxND_classname()
	UCharBoxND_classname = _npstat.UCharBoxND_classname

	def UCharBoxND_version() -> "unsigned int":
	return _npstat.UCharBoxND_version()
	UCharBoxND_version = _npstat.UCharBoxND_version

	def UCharBoxND_restore(id: 'ClassId', arg3: 'istream', box: 'UCharBoxND') -> "void":
	return _npstat.UCharBoxND_restore(id, arg3, box)
	UCharBoxND_restore = _npstat.UCharBoxND_restore

	class ArchiveRecord_UCharBoxND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_UCharBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_UCharBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'UCharBoxND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_UCharBoxND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_UCharBoxND
	__del__ = lambda self: None
	ArchiveRecord_UCharBoxND_swigregister = _npstat.ArchiveRecord_UCharBoxND_swigregister
	ArchiveRecord_UCharBoxND_swigregister(ArchiveRecord_UCharBoxND)

	class Ref_UCharBoxND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_UCharBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_UCharBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_UCharBoxND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'UCharBoxND') -> "void":
	return _npstat.Ref_UCharBoxND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::BoxND< unsigned char > *":
	return _npstat.Ref_UCharBoxND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::BoxND< unsigned char >":
	return _npstat.Ref_UCharBoxND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_UCharBoxND
	__del__ = lambda self: None
	Ref_UCharBoxND_swigregister = _npstat.Ref_UCharBoxND_swigregister
	Ref_UCharBoxND_swigregister(Ref_UCharBoxND)

	class IntBoxND(IntIntervalVector):
	__swig_setmethods__ = {}
	for _s in [IntIntervalVector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [IntIntervalVector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, IntBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_IntBoxND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned long":
	return _npstat.IntBoxND_dim(self)

	def volume(self) -> "int":
	return _npstat.IntBoxND_volume(self)

	def getMidpoint(self, coord: 'int *', coordLen: 'unsigned long') -> "void":
	return _npstat.IntBoxND_getMidpoint(self, coord, coordLen)

	def __imul__(self, *args) -> "npstat::BoxND< int > &":
	return _npstat.IntBoxND___imul__(self, *args)

	def __itruediv__(self, *args):
	return _npstat.IntBoxND___itruediv__(self, *args)
	__idiv__ = __itruediv__



	def expand(self, *args) -> "npstat::BoxND< int > &":
	return _npstat.IntBoxND_expand(self, *args)

	def moveToOrigin(self) -> "npstat::BoxND< int > &":
	return _npstat.IntBoxND_moveToOrigin(self)

	def overlapVolume(self, r: 'IntBoxND') -> "int":
	return _npstat.IntBoxND_overlapVolume(self, r)

	def overlapFraction(self, r: 'IntBoxND') -> "double":
	return _npstat.IntBoxND_overlapFraction(self, r)
	if _newclass:
	unitBox = staticmethod(_npstat.IntBoxND_unitBox)
	else:
	unitBox = _npstat.IntBoxND_unitBox
	if _newclass:
	sizeTwoBox = staticmethod(_npstat.IntBoxND_sizeTwoBox)
	else:
	sizeTwoBox = _npstat.IntBoxND_sizeTwoBox
	if _newclass:
	allSpace = staticmethod(_npstat.IntBoxND_allSpace)
	else:
	allSpace = _npstat.IntBoxND_allSpace

	def classId(self) -> "gs::ClassId":
	return _npstat.IntBoxND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.IntBoxND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.IntBoxND_classname)
	else:
	classname = _npstat.IntBoxND_classname
	if _newclass:
	version = staticmethod(_npstat.IntBoxND_version)
	else:
	version = _npstat.IntBoxND_version
	if _newclass:
	restore = staticmethod(_npstat.IntBoxND_restore)
	else:
	restore = _npstat.IntBoxND_restore
	__swig_destroy__ = _npstat.delete_IntBoxND
	__del__ = lambda self: None
	IntBoxND_swigregister = _npstat.IntBoxND_swigregister
	IntBoxND_swigregister(IntBoxND)

	def IntBoxND_unitBox(ndim: 'unsigned long') -> "npstat::BoxND< int >":
	return _npstat.IntBoxND_unitBox(ndim)
	IntBoxND_unitBox = _npstat.IntBoxND_unitBox

	def IntBoxND_sizeTwoBox(ndim: 'unsigned long') -> "npstat::BoxND< int >":
	return _npstat.IntBoxND_sizeTwoBox(ndim)
	IntBoxND_sizeTwoBox = _npstat.IntBoxND_sizeTwoBox

	def IntBoxND_allSpace(ndim: 'unsigned long') -> "npstat::BoxND< int >":
	return _npstat.IntBoxND_allSpace(ndim)
	IntBoxND_allSpace = _npstat.IntBoxND_allSpace

	def IntBoxND_classname() -> "char const *":
	return _npstat.IntBoxND_classname()
	IntBoxND_classname = _npstat.IntBoxND_classname

	def IntBoxND_version() -> "unsigned int":
	return _npstat.IntBoxND_version()
	IntBoxND_version = _npstat.IntBoxND_version

	def IntBoxND_restore(id: 'ClassId', arg3: 'istream', box: 'IntBoxND') -> "void":
	return _npstat.IntBoxND_restore(id, arg3, box)
	IntBoxND_restore = _npstat.IntBoxND_restore

	class ArchiveRecord_IntBoxND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_IntBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_IntBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'IntBoxND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_IntBoxND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_IntBoxND
	__del__ = lambda self: None
	ArchiveRecord_IntBoxND_swigregister = _npstat.ArchiveRecord_IntBoxND_swigregister
	ArchiveRecord_IntBoxND_swigregister(ArchiveRecord_IntBoxND)

	class Ref_IntBoxND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_IntBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_IntBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_IntBoxND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'IntBoxND') -> "void":
	return _npstat.Ref_IntBoxND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::BoxND< int > *":
	return _npstat.Ref_IntBoxND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::BoxND< int >":
	return _npstat.Ref_IntBoxND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_IntBoxND
	__del__ = lambda self: None
	Ref_IntBoxND_swigregister = _npstat.Ref_IntBoxND_swigregister
	Ref_IntBoxND_swigregister(Ref_IntBoxND)

	class LLongBoxND(LLongIntervalVector):
	__swig_setmethods__ = {}
	for _s in [LLongIntervalVector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [LLongIntervalVector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LLongBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_LLongBoxND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned long":
	return _npstat.LLongBoxND_dim(self)

	def volume(self) -> "long long":
	return _npstat.LLongBoxND_volume(self)

	def getMidpoint(self, coord: 'long long *', coordLen: 'unsigned long') -> "void":
	return _npstat.LLongBoxND_getMidpoint(self, coord, coordLen)

	def __imul__(self, *args) -> "npstat::BoxND< long long > &":
	return _npstat.LLongBoxND___imul__(self, *args)

	def __itruediv__(self, *args):
	return _npstat.LLongBoxND___itruediv__(self, *args)
	__idiv__ = __itruediv__



	def expand(self, *args) -> "npstat::BoxND< long long > &":
	return _npstat.LLongBoxND_expand(self, *args)

	def moveToOrigin(self) -> "npstat::BoxND< long long > &":
	return _npstat.LLongBoxND_moveToOrigin(self)

	def overlapVolume(self, r: 'LLongBoxND') -> "long long":
	return _npstat.LLongBoxND_overlapVolume(self, r)

	def overlapFraction(self, r: 'LLongBoxND') -> "double":
	return _npstat.LLongBoxND_overlapFraction(self, r)
	if _newclass:
	unitBox = staticmethod(_npstat.LLongBoxND_unitBox)
	else:
	unitBox = _npstat.LLongBoxND_unitBox
	if _newclass:
	sizeTwoBox = staticmethod(_npstat.LLongBoxND_sizeTwoBox)
	else:
	sizeTwoBox = _npstat.LLongBoxND_sizeTwoBox
	if _newclass:
	allSpace = staticmethod(_npstat.LLongBoxND_allSpace)
	else:
	allSpace = _npstat.LLongBoxND_allSpace

	def classId(self) -> "gs::ClassId":
	return _npstat.LLongBoxND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.LLongBoxND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.LLongBoxND_classname)
	else:
	classname = _npstat.LLongBoxND_classname
	if _newclass:
	version = staticmethod(_npstat.LLongBoxND_version)
	else:
	version = _npstat.LLongBoxND_version
	if _newclass:
	restore = staticmethod(_npstat.LLongBoxND_restore)
	else:
	restore = _npstat.LLongBoxND_restore
	__swig_destroy__ = _npstat.delete_LLongBoxND
	__del__ = lambda self: None
	LLongBoxND_swigregister = _npstat.LLongBoxND_swigregister
	LLongBoxND_swigregister(LLongBoxND)

	def LLongBoxND_unitBox(ndim: 'unsigned long') -> "npstat::BoxND< long long >":
	return _npstat.LLongBoxND_unitBox(ndim)
	LLongBoxND_unitBox = _npstat.LLongBoxND_unitBox

	def LLongBoxND_sizeTwoBox(ndim: 'unsigned long') -> "npstat::BoxND< long long >":
	return _npstat.LLongBoxND_sizeTwoBox(ndim)
	LLongBoxND_sizeTwoBox = _npstat.LLongBoxND_sizeTwoBox

	def LLongBoxND_allSpace(ndim: 'unsigned long') -> "npstat::BoxND< long long >":
	return _npstat.LLongBoxND_allSpace(ndim)
	LLongBoxND_allSpace = _npstat.LLongBoxND_allSpace

	def LLongBoxND_classname() -> "char const *":
	return _npstat.LLongBoxND_classname()
	LLongBoxND_classname = _npstat.LLongBoxND_classname

	def LLongBoxND_version() -> "unsigned int":
	return _npstat.LLongBoxND_version()
	LLongBoxND_version = _npstat.LLongBoxND_version

	def LLongBoxND_restore(id: 'ClassId', arg3: 'istream', box: 'LLongBoxND') -> "void":
	return _npstat.LLongBoxND_restore(id, arg3, box)
	LLongBoxND_restore = _npstat.LLongBoxND_restore

	class ArchiveRecord_LLongBoxND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_LLongBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_LLongBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'LLongBoxND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_LLongBoxND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_LLongBoxND
	__del__ = lambda self: None
	ArchiveRecord_LLongBoxND_swigregister = _npstat.ArchiveRecord_LLongBoxND_swigregister
	ArchiveRecord_LLongBoxND_swigregister(ArchiveRecord_LLongBoxND)

	class Ref_LLongBoxND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_LLongBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_LLongBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_LLongBoxND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'LLongBoxND') -> "void":
	return _npstat.Ref_LLongBoxND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::BoxND< long long > *":
	return _npstat.Ref_LLongBoxND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::BoxND< long long >":
	return _npstat.Ref_LLongBoxND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_LLongBoxND
	__del__ = lambda self: None
	Ref_LLongBoxND_swigregister = _npstat.Ref_LLongBoxND_swigregister
	Ref_LLongBoxND_swigregister(Ref_LLongBoxND)

	class FloatBoxND(FloatIntervalVector):
	__swig_setmethods__ = {}
	for _s in [FloatIntervalVector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [FloatIntervalVector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_FloatBoxND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned long":
	return _npstat.FloatBoxND_dim(self)

	def volume(self) -> "float":
	return _npstat.FloatBoxND_volume(self)

	def getMidpoint(self, coord: 'float *', coordLen: 'unsigned long') -> "void":
	return _npstat.FloatBoxND_getMidpoint(self, coord, coordLen)

	def __imul__(self, *args) -> "npstat::BoxND< float > &":
	return _npstat.FloatBoxND___imul__(self, *args)

	def __itruediv__(self, *args):
	return _npstat.FloatBoxND___itruediv__(self, *args)
	__idiv__ = __itruediv__



	def expand(self, *args) -> "npstat::BoxND< float > &":
	return _npstat.FloatBoxND_expand(self, *args)

	def moveToOrigin(self) -> "npstat::BoxND< float > &":
	return _npstat.FloatBoxND_moveToOrigin(self)

	def overlapVolume(self, r: 'FloatBoxND') -> "float":
	return _npstat.FloatBoxND_overlapVolume(self, r)

	def overlapFraction(self, r: 'FloatBoxND') -> "double":
	return _npstat.FloatBoxND_overlapFraction(self, r)
	if _newclass:
	unitBox = staticmethod(_npstat.FloatBoxND_unitBox)
	else:
	unitBox = _npstat.FloatBoxND_unitBox
	if _newclass:
	sizeTwoBox = staticmethod(_npstat.FloatBoxND_sizeTwoBox)
	else:
	sizeTwoBox = _npstat.FloatBoxND_sizeTwoBox
	if _newclass:
	allSpace = staticmethod(_npstat.FloatBoxND_allSpace)
	else:
	allSpace = _npstat.FloatBoxND_allSpace

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatBoxND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatBoxND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatBoxND_classname)
	else:
	classname = _npstat.FloatBoxND_classname
	if _newclass:
	version = staticmethod(_npstat.FloatBoxND_version)
	else:
	version = _npstat.FloatBoxND_version
	if _newclass:
	restore = staticmethod(_npstat.FloatBoxND_restore)
	else:
	restore = _npstat.FloatBoxND_restore
	__swig_destroy__ = _npstat.delete_FloatBoxND
	__del__ = lambda self: None
	FloatBoxND_swigregister = _npstat.FloatBoxND_swigregister
	FloatBoxND_swigregister(FloatBoxND)

	def FloatBoxND_unitBox(ndim: 'unsigned long') -> "npstat::BoxND< float >":
	return _npstat.FloatBoxND_unitBox(ndim)
	FloatBoxND_unitBox = _npstat.FloatBoxND_unitBox

	def FloatBoxND_sizeTwoBox(ndim: 'unsigned long') -> "npstat::BoxND< float >":
	return _npstat.FloatBoxND_sizeTwoBox(ndim)
	FloatBoxND_sizeTwoBox = _npstat.FloatBoxND_sizeTwoBox

	def FloatBoxND_allSpace(ndim: 'unsigned long') -> "npstat::BoxND< float >":
	return _npstat.FloatBoxND_allSpace(ndim)
	FloatBoxND_allSpace = _npstat.FloatBoxND_allSpace

	def FloatBoxND_classname() -> "char const *":
	return _npstat.FloatBoxND_classname()
	FloatBoxND_classname = _npstat.FloatBoxND_classname

	def FloatBoxND_version() -> "unsigned int":
	return _npstat.FloatBoxND_version()
	FloatBoxND_version = _npstat.FloatBoxND_version

	def FloatBoxND_restore(id: 'ClassId', arg3: 'istream', box: 'FloatBoxND') -> "void":
	return _npstat.FloatBoxND_restore(id, arg3, box)
	FloatBoxND_restore = _npstat.FloatBoxND_restore

	class ArchiveRecord_FloatBoxND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_FloatBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_FloatBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'FloatBoxND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_FloatBoxND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_FloatBoxND
	__del__ = lambda self: None
	ArchiveRecord_FloatBoxND_swigregister = _npstat.ArchiveRecord_FloatBoxND_swigregister
	ArchiveRecord_FloatBoxND_swigregister(ArchiveRecord_FloatBoxND)

	class Ref_FloatBoxND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_FloatBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_FloatBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_FloatBoxND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'FloatBoxND') -> "void":
	return _npstat.Ref_FloatBoxND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::BoxND< float > *":
	return _npstat.Ref_FloatBoxND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::BoxND< float >":
	return _npstat.Ref_FloatBoxND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_FloatBoxND
	__del__ = lambda self: None
	Ref_FloatBoxND_swigregister = _npstat.Ref_FloatBoxND_swigregister
	Ref_FloatBoxND_swigregister(Ref_FloatBoxND)

	class DoubleBoxND(DoubleIntervalVector):
	__swig_setmethods__ = {}
	for _s in [DoubleIntervalVector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleIntervalVector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_DoubleBoxND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned long":
	return _npstat.DoubleBoxND_dim(self)

	def volume(self) -> "double":
	return _npstat.DoubleBoxND_volume(self)

	def getMidpoint(self, coord: 'double *', coordLen: 'unsigned long') -> "void":
	return _npstat.DoubleBoxND_getMidpoint(self, coord, coordLen)

	def __imul__(self, *args) -> "npstat::BoxND< double > &":
	return _npstat.DoubleBoxND___imul__(self, *args)

	def __itruediv__(self, *args):
	return _npstat.DoubleBoxND___itruediv__(self, *args)
	__idiv__ = __itruediv__



	def expand(self, *args) -> "npstat::BoxND< double > &":
	return _npstat.DoubleBoxND_expand(self, *args)

	def moveToOrigin(self) -> "npstat::BoxND< double > &":
	return _npstat.DoubleBoxND_moveToOrigin(self)

	def overlapVolume(self, r: 'DoubleBoxND') -> "double":
	return _npstat.DoubleBoxND_overlapVolume(self, r)

	def overlapFraction(self, r: 'DoubleBoxND') -> "double":
	return _npstat.DoubleBoxND_overlapFraction(self, r)
	if _newclass:
	unitBox = staticmethod(_npstat.DoubleBoxND_unitBox)
	else:
	unitBox = _npstat.DoubleBoxND_unitBox
	if _newclass:
	sizeTwoBox = staticmethod(_npstat.DoubleBoxND_sizeTwoBox)
	else:
	sizeTwoBox = _npstat.DoubleBoxND_sizeTwoBox
	if _newclass:
	allSpace = staticmethod(_npstat.DoubleBoxND_allSpace)
	else:
	allSpace = _npstat.DoubleBoxND_allSpace

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleBoxND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleBoxND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleBoxND_classname)
	else:
	classname = _npstat.DoubleBoxND_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleBoxND_version)
	else:
	version = _npstat.DoubleBoxND_version
	if _newclass:
	restore = staticmethod(_npstat.DoubleBoxND_restore)
	else:
	restore = _npstat.DoubleBoxND_restore
	__swig_destroy__ = _npstat.delete_DoubleBoxND
	__del__ = lambda self: None
	DoubleBoxND_swigregister = _npstat.DoubleBoxND_swigregister
	DoubleBoxND_swigregister(DoubleBoxND)

	def DoubleBoxND_unitBox(ndim: 'unsigned long') -> "npstat::BoxND< double >":
	return _npstat.DoubleBoxND_unitBox(ndim)
	DoubleBoxND_unitBox = _npstat.DoubleBoxND_unitBox

	def DoubleBoxND_sizeTwoBox(ndim: 'unsigned long') -> "npstat::BoxND< double >":
	return _npstat.DoubleBoxND_sizeTwoBox(ndim)
	DoubleBoxND_sizeTwoBox = _npstat.DoubleBoxND_sizeTwoBox

	def DoubleBoxND_allSpace(ndim: 'unsigned long') -> "npstat::BoxND< double >":
	return _npstat.DoubleBoxND_allSpace(ndim)
	DoubleBoxND_allSpace = _npstat.DoubleBoxND_allSpace

	def DoubleBoxND_classname() -> "char const *":
	return _npstat.DoubleBoxND_classname()
	DoubleBoxND_classname = _npstat.DoubleBoxND_classname

	def DoubleBoxND_version() -> "unsigned int":
	return _npstat.DoubleBoxND_version()
	DoubleBoxND_version = _npstat.DoubleBoxND_version

	def DoubleBoxND_restore(id: 'ClassId', arg3: 'istream', box: 'DoubleBoxND') -> "void":
	return _npstat.DoubleBoxND_restore(id, arg3, box)
	DoubleBoxND_restore = _npstat.DoubleBoxND_restore

	class ArchiveRecord_DoubleBoxND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DoubleBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DoubleBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DoubleBoxND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DoubleBoxND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DoubleBoxND
	__del__ = lambda self: None
	ArchiveRecord_DoubleBoxND_swigregister = _npstat.ArchiveRecord_DoubleBoxND_swigregister
	ArchiveRecord_DoubleBoxND_swigregister(ArchiveRecord_DoubleBoxND)

	class Ref_DoubleBoxND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DoubleBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DoubleBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DoubleBoxND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DoubleBoxND') -> "void":
	return _npstat.Ref_DoubleBoxND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::BoxND< double > *":
	return _npstat.Ref_DoubleBoxND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::BoxND< double >":
	return _npstat.Ref_DoubleBoxND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DoubleBoxND
	__del__ = lambda self: None
	Ref_DoubleBoxND_swigregister = _npstat.Ref_DoubleBoxND_swigregister
	Ref_DoubleBoxND_swigregister(Ref_DoubleBoxND)

	class UIntBoxND(UIntIntervalVector):
	__swig_setmethods__ = {}
	for _s in [UIntIntervalVector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UIntBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [UIntIntervalVector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UIntBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_UIntBoxND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned long":
	return _npstat.UIntBoxND_dim(self)

	def volume(self) -> "unsigned int":
	return _npstat.UIntBoxND_volume(self)

	def getMidpoint(self, coord: 'unsigned int *', coordLen: 'unsigned long') -> "void":
	return _npstat.UIntBoxND_getMidpoint(self, coord, coordLen)

	def __imul__(self, *args) -> "npstat::BoxND< unsigned int > &":
	return _npstat.UIntBoxND___imul__(self, *args)

	def __itruediv__(self, *args):
	return _npstat.UIntBoxND___itruediv__(self, *args)
	__idiv__ = __itruediv__



	def expand(self, *args) -> "npstat::BoxND< unsigned int > &":
	return _npstat.UIntBoxND_expand(self, *args)

	def moveToOrigin(self) -> "npstat::BoxND< unsigned int > &":
	return _npstat.UIntBoxND_moveToOrigin(self)

	def overlapVolume(self, r: 'UIntBoxND') -> "unsigned int":
	return _npstat.UIntBoxND_overlapVolume(self, r)

	def overlapFraction(self, r: 'UIntBoxND') -> "double":
	return _npstat.UIntBoxND_overlapFraction(self, r)
	if _newclass:
	unitBox = staticmethod(_npstat.UIntBoxND_unitBox)
	else:
	unitBox = _npstat.UIntBoxND_unitBox
	if _newclass:
	sizeTwoBox = staticmethod(_npstat.UIntBoxND_sizeTwoBox)
	else:
	sizeTwoBox = _npstat.UIntBoxND_sizeTwoBox
	if _newclass:
	allSpace = staticmethod(_npstat.UIntBoxND_allSpace)
	else:
	allSpace = _npstat.UIntBoxND_allSpace

	def classId(self) -> "gs::ClassId":
	return _npstat.UIntBoxND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.UIntBoxND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.UIntBoxND_classname)
	else:
	classname = _npstat.UIntBoxND_classname
	if _newclass:
	version = staticmethod(_npstat.UIntBoxND_version)
	else:
	version = _npstat.UIntBoxND_version
	if _newclass:
	restore = staticmethod(_npstat.UIntBoxND_restore)
	else:
	restore = _npstat.UIntBoxND_restore
	__swig_destroy__ = _npstat.delete_UIntBoxND
	__del__ = lambda self: None
	UIntBoxND_swigregister = _npstat.UIntBoxND_swigregister
	UIntBoxND_swigregister(UIntBoxND)

	def UIntBoxND_unitBox(ndim: 'unsigned long') -> "npstat::BoxND< unsigned int >":
	return _npstat.UIntBoxND_unitBox(ndim)
	UIntBoxND_unitBox = _npstat.UIntBoxND_unitBox

	def UIntBoxND_sizeTwoBox(ndim: 'unsigned long') -> "npstat::BoxND< unsigned int >":
	return _npstat.UIntBoxND_sizeTwoBox(ndim)
	UIntBoxND_sizeTwoBox = _npstat.UIntBoxND_sizeTwoBox

	def UIntBoxND_allSpace(ndim: 'unsigned long') -> "npstat::BoxND< unsigned int >":
	return _npstat.UIntBoxND_allSpace(ndim)
	UIntBoxND_allSpace = _npstat.UIntBoxND_allSpace

	def UIntBoxND_classname() -> "char const *":
	return _npstat.UIntBoxND_classname()
	UIntBoxND_classname = _npstat.UIntBoxND_classname

	def UIntBoxND_version() -> "unsigned int":
	return _npstat.UIntBoxND_version()
	UIntBoxND_version = _npstat.UIntBoxND_version

	def UIntBoxND_restore(id: 'ClassId', arg3: 'istream', box: 'UIntBoxND') -> "void":
	return _npstat.UIntBoxND_restore(id, arg3, box)
	UIntBoxND_restore = _npstat.UIntBoxND_restore

	class ArchiveRecord_UIntBoxND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_UIntBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_UIntBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'UIntBoxND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_UIntBoxND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_UIntBoxND
	__del__ = lambda self: None
	ArchiveRecord_UIntBoxND_swigregister = _npstat.ArchiveRecord_UIntBoxND_swigregister
	ArchiveRecord_UIntBoxND_swigregister(ArchiveRecord_UIntBoxND)

	class Ref_UIntBoxND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_UIntBoxND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_UIntBoxND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_UIntBoxND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'UIntBoxND') -> "void":
	return _npstat.Ref_UIntBoxND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::BoxND< unsigned int > *":
	return _npstat.Ref_UIntBoxND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::BoxND< unsigned int >":
	return _npstat.Ref_UIntBoxND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_UIntBoxND
	__del__ = lambda self: None
	Ref_UIntBoxND_swigregister = _npstat.Ref_UIntBoxND_swigregister
	Ref_UIntBoxND_swigregister(Ref_UIntBoxND)

	class ArrayRange(UIntBoxND):
	__swig_setmethods__ = {}
	for _s in [UIntBoxND]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArrayRange, name, value)
	__swig_getmethods__ = {}
	for _s in [UIntBoxND]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArrayRange, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_ArrayRange(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def shape(self) -> "npstat::ArrayShape":
	return _npstat.ArrayRange_shape(self)

	def isCompatible(self, *args) -> "bool":
	return _npstat.ArrayRange_isCompatible(self, *args)

	def rangeSize(self) -> "unsigned long":
	return _npstat.ArrayRange_rangeSize(self)

	def __lt__(self, arg2: 'ArrayRange') -> "bool":
	return _npstat.ArrayRange___lt__(self, arg2)

	def stripOuterLayer(self) -> "npstat::ArrayRange &":
	return _npstat.ArrayRange_stripOuterLayer(self)

	def lowerLimits(self, limits: 'unsigned int *', limitsLen: 'unsigned int') -> "void":
	return _npstat.ArrayRange_lowerLimits(self, limits, limitsLen)

	def upperLimits(self, limits: 'unsigned int *', limitsLen: 'unsigned int') -> "void":
	return _npstat.ArrayRange_upperLimits(self, limits, limitsLen)

	def rangeLength(self, range: 'unsigned int *', rangeLen: 'unsigned int') -> "void":
	return _npstat.ArrayRange_rangeLength(self, range, rangeLen)

	def classId(self) -> "gs::ClassId":
	return _npstat.ArrayRange_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.ArrayRange_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.ArrayRange_classname)
	else:
	classname = _npstat.ArrayRange_classname
	if _newclass:
	version = staticmethod(_npstat.ArrayRange_version)
	else:
	version = _npstat.ArrayRange_version
	if _newclass:
	restore = staticmethod(_npstat.ArrayRange_restore)
	else:
	restore = _npstat.ArrayRange_restore
	__swig_destroy__ = _npstat.delete_ArrayRange
	__del__ = lambda self: None
	ArrayRange_swigregister = _npstat.ArrayRange_swigregister
	ArrayRange_swigregister(ArrayRange)

	def ArrayRange_classname() -> "char const *":
	return _npstat.ArrayRange_classname()
	ArrayRange_classname = _npstat.ArrayRange_classname

	def ArrayRange_version() -> "unsigned int":
	return _npstat.ArrayRange_version()
	ArrayRange_version = _npstat.ArrayRange_version

	def ArrayRange_restore(id: 'ClassId', arg3: 'istream', box: 'ArrayRange') -> "void":
	return _npstat.ArrayRange_restore(id, arg3, box)
	ArrayRange_restore = _npstat.ArrayRange_restore

	class StatAccumulator(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, StatAccumulator, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, StatAccumulator, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_StatAccumulator()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def count(self) -> "unsigned long":
	return _npstat.StatAccumulator_count(self)

	def min(self) -> "double":
	return _npstat.StatAccumulator_min(self)

	def max(self) -> "double":
	return _npstat.StatAccumulator_max(self)

	def sum(self) -> "long double":
	return _npstat.StatAccumulator_sum(self)

	def sumsq(self) -> "long double":
	return _npstat.StatAccumulator_sumsq(self)

	def mean(self) -> "double":
	return _npstat.StatAccumulator_mean(self)

	def stdev(self) -> "double":
	return _npstat.StatAccumulator_stdev(self)

	def meanUncertainty(self) -> "double":
	return _npstat.StatAccumulator_meanUncertainty(self)

	def location(self) -> "double":
	return _npstat.StatAccumulator_location(self)

	def rangeDown(self) -> "double":
	return _npstat.StatAccumulator_rangeDown(self)

	def rangeUp(self) -> "double":
	return _npstat.StatAccumulator_rangeUp(self)

	def noThrowMean(self, valueIfNoData: 'double'=0.0) -> "double":
	return _npstat.StatAccumulator_noThrowMean(self, valueIfNoData)

	def noThrowStdev(self, valueIfNoData: 'double'=0.0) -> "double":
	return _npstat.StatAccumulator_noThrowStdev(self, valueIfNoData)

	def noThrowMeanUncertainty(self, valueIfNoData: 'double'=0.0) -> "double":
	return _npstat.StatAccumulator_noThrowMeanUncertainty(self, valueIfNoData)

	def __iadd__(self, *args) -> "npstat::StatAccumulator &":
	return _npstat.StatAccumulator___iadd__(self, *args)

	def accumulate(self, *args) -> "void":
	return _npstat.StatAccumulator_accumulate(self, *args)

	def __add__(self, r: 'StatAccumulator') -> "npstat::StatAccumulator":
	return _npstat.StatAccumulator___add__(self, r)

	def reset(self) -> "void":
	return _npstat.StatAccumulator_reset(self)

	def __eq__(self, r: 'StatAccumulator') -> "bool":
	return _npstat.StatAccumulator___eq__(self, r)

	def __ne__(self, r: 'StatAccumulator') -> "bool":
	return _npstat.StatAccumulator___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.StatAccumulator_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.StatAccumulator_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.StatAccumulator_classname)
	else:
	classname = _npstat.StatAccumulator_classname
	if _newclass:
	version = staticmethod(_npstat.StatAccumulator_version)
	else:
	version = _npstat.StatAccumulator_version
	if _newclass:
	restore = staticmethod(_npstat.StatAccumulator_restore)
	else:
	restore = _npstat.StatAccumulator_restore

	def __mul__(self, r: 'double const') -> "npstat::StatAccumulator":
	return _npstat.StatAccumulator___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::StatAccumulator":
	return _npstat.StatAccumulator___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::StatAccumulator &":
	return _npstat.StatAccumulator___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::StatAccumulator &":
	return _npstat.StatAccumulator___idiv__(self, r)

	def accumulateAll(self, values: 'DoubleVector') -> "void":
	return _npstat.StatAccumulator_accumulateAll(self, values)
	__swig_destroy__ = _npstat.delete_StatAccumulator
	__del__ = lambda self: None
	StatAccumulator_swigregister = _npstat.StatAccumulator_swigregister
	StatAccumulator_swigregister(StatAccumulator)

	def StatAccumulator_classname() -> "char const *":
	return _npstat.StatAccumulator_classname()
	StatAccumulator_classname = _npstat.StatAccumulator_classname

	def StatAccumulator_version() -> "unsigned int":
	return _npstat.StatAccumulator_version()
	StatAccumulator_version = _npstat.StatAccumulator_version

	def StatAccumulator_restore(id: 'ClassId', arg3: 'istream', acc: 'StatAccumulator') -> "void":
	return _npstat.StatAccumulator_restore(id, arg3, acc)
	StatAccumulator_restore = _npstat.StatAccumulator_restore

	class WeightedStatAccumulator(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, WeightedStatAccumulator, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, WeightedStatAccumulator, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_WeightedStatAccumulator()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def min(self) -> "double":
	return _npstat.WeightedStatAccumulator_min(self)

	def max(self) -> "double":
	return _npstat.WeightedStatAccumulator_max(self)

	def maxWeight(self) -> "double":
	return _npstat.WeightedStatAccumulator_maxWeight(self)

	def mean(self) -> "double":
	return _npstat.WeightedStatAccumulator_mean(self)

	def stdev(self) -> "double":
	return _npstat.WeightedStatAccumulator_stdev(self)

	def meanUncertainty(self) -> "double":
	return _npstat.WeightedStatAccumulator_meanUncertainty(self)

	def location(self) -> "double":
	return _npstat.WeightedStatAccumulator_location(self)

	def rangeDown(self) -> "double":
	return _npstat.WeightedStatAccumulator_rangeDown(self)

	def rangeUp(self) -> "double":
	return _npstat.WeightedStatAccumulator_rangeUp(self)

	def noThrowMean(self, valueIfNoData: 'double'=0.0) -> "double":
	return _npstat.WeightedStatAccumulator_noThrowMean(self, valueIfNoData)

	def noThrowStdev(self, valueIfNoData: 'double'=0.0) -> "double":
	return _npstat.WeightedStatAccumulator_noThrowStdev(self, valueIfNoData)

	def noThrowMeanUncertainty(self, valueIfNoData: 'double'=0.0) -> "double":
	return _npstat.WeightedStatAccumulator_noThrowMeanUncertainty(self, valueIfNoData)

	def count(self) -> "double":
	return _npstat.WeightedStatAccumulator_count(self)

	def ncalls(self) -> "unsigned long":
	return _npstat.WeightedStatAccumulator_ncalls(self)

	def nfills(self) -> "unsigned long":
	return _npstat.WeightedStatAccumulator_nfills(self)

	def averageWeight(self) -> "double":
	return _npstat.WeightedStatAccumulator_averageWeight(self)

	def sumOfWeights(self) -> "double":
	return _npstat.WeightedStatAccumulator_sumOfWeights(self)

	def accumulate(self, *args) -> "void":
	return _npstat.WeightedStatAccumulator_accumulate(self, *args)

	def __add__(self, r: 'WeightedStatAccumulator') -> "npstat::WeightedStatAccumulator":
	return _npstat.WeightedStatAccumulator___add__(self, r)

	def scaleWeights(self, r: 'double') -> "npstat::WeightedStatAccumulator &":
	return _npstat.WeightedStatAccumulator_scaleWeights(self, r)

	def reset(self) -> "void":
	return _npstat.WeightedStatAccumulator_reset(self)

	def __eq__(self, r: 'WeightedStatAccumulator') -> "bool":
	return _npstat.WeightedStatAccumulator___eq__(self, r)

	def __ne__(self, r: 'WeightedStatAccumulator') -> "bool":
	return _npstat.WeightedStatAccumulator___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.WeightedStatAccumulator_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.WeightedStatAccumulator_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.WeightedStatAccumulator_classname)
	else:
	classname = _npstat.WeightedStatAccumulator_classname
	if _newclass:
	version = staticmethod(_npstat.WeightedStatAccumulator_version)
	else:
	version = _npstat.WeightedStatAccumulator_version
	if _newclass:
	restore = staticmethod(_npstat.WeightedStatAccumulator_restore)
	else:
	restore = _npstat.WeightedStatAccumulator_restore

	def __mul__(self, r: 'double const') -> "npstat::WeightedStatAccumulator":
	return _npstat.WeightedStatAccumulator___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::WeightedStatAccumulator":
	return _npstat.WeightedStatAccumulator___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::WeightedStatAccumulator &":
	return _npstat.WeightedStatAccumulator___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::WeightedStatAccumulator &":
	return _npstat.WeightedStatAccumulator___idiv__(self, r)

	def __iadd__(self, *args) -> "npstat::WeightedStatAccumulator &":
	return _npstat.WeightedStatAccumulator___iadd__(self, *args)
	__swig_destroy__ = _npstat.delete_WeightedStatAccumulator
	__del__ = lambda self: None
	WeightedStatAccumulator_swigregister = _npstat.WeightedStatAccumulator_swigregister
	WeightedStatAccumulator_swigregister(WeightedStatAccumulator)

	def WeightedStatAccumulator_classname() -> "char const *":
	return _npstat.WeightedStatAccumulator_classname()
	WeightedStatAccumulator_classname = _npstat.WeightedStatAccumulator_classname

	def WeightedStatAccumulator_version() -> "unsigned int":
	return _npstat.WeightedStatAccumulator_version()
	WeightedStatAccumulator_version = _npstat.WeightedStatAccumulator_version

	def WeightedStatAccumulator_restore(id: 'ClassId', arg3: 'istream', acc: 'WeightedStatAccumulator') -> "void":
	return _npstat.WeightedStatAccumulator_restore(id, arg3, acc)
	WeightedStatAccumulator_restore = _npstat.WeightedStatAccumulator_restore

	class FloatWeightedSampleAccumulator(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatWeightedSampleAccumulator, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatWeightedSampleAccumulator, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_FloatWeightedSampleAccumulator()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def maxWeight(self) -> "double":
	return _npstat.FloatWeightedSampleAccumulator_maxWeight(self)

	def ncalls(self) -> "unsigned long":
	return _npstat.FloatWeightedSampleAccumulator_ncalls(self)

	def nfills(self) -> "unsigned long":
	return _npstat.FloatWeightedSampleAccumulator_nfills(self)

	def count(self) -> "double":
	return _npstat.FloatWeightedSampleAccumulator_count(self)

	def min(self) -> "float":
	return _npstat.FloatWeightedSampleAccumulator_min(self)

	def max(self) -> "float":
	return _npstat.FloatWeightedSampleAccumulator_max(self)

	def mean(self) -> "long double":
	return _npstat.FloatWeightedSampleAccumulator_mean(self)

	def stdev(self) -> "long double":
	return _npstat.FloatWeightedSampleAccumulator_stdev(self)

	def meanUncertainty(self) -> "long double":
	return _npstat.FloatWeightedSampleAccumulator_meanUncertainty(self)

	def median(self) -> "float":
	return _npstat.FloatWeightedSampleAccumulator_median(self)

	def cdf(self, value: 'float') -> "double":
	return _npstat.FloatWeightedSampleAccumulator_cdf(self, value)

	def weightBelow(self, value: 'float') -> "double":
	return _npstat.FloatWeightedSampleAccumulator_weightBelow(self, value)

	def quantile(self, x: 'double') -> "float":
	return _npstat.FloatWeightedSampleAccumulator_quantile(self, x)

	def location(self) -> "float":
	return _npstat.FloatWeightedSampleAccumulator_location(self)

	def rangeDown(self) -> "float":
	return _npstat.FloatWeightedSampleAccumulator_rangeDown(self)

	def rangeUp(self) -> "float":
	return _npstat.FloatWeightedSampleAccumulator_rangeUp(self)

	def noThrowMean(self, valueIfNoData: 'long double const &') -> "long double":
	return _npstat.FloatWeightedSampleAccumulator_noThrowMean(self, valueIfNoData)

	def noThrowStdev(self, valueIfNoData: 'long double const &') -> "long double":
	return _npstat.FloatWeightedSampleAccumulator_noThrowStdev(self, valueIfNoData)

	def noThrowMeanUncertainty(self, valueIfNoData: 'long double const &') -> "long double":
	return _npstat.FloatWeightedSampleAccumulator_noThrowMeanUncertainty(self, valueIfNoData)

	def averageWeight(self) -> "double":
	return _npstat.FloatWeightedSampleAccumulator_averageWeight(self)

	def sumOfWeights(self) -> "double":
	return _npstat.FloatWeightedSampleAccumulator_sumOfWeights(self)

	def data(self) -> "std::pair< float,double > const *":
	return _npstat.FloatWeightedSampleAccumulator_data(self)

	def __eq__(self, r: 'FloatWeightedSampleAccumulator') -> "bool":
	return _npstat.FloatWeightedSampleAccumulator___eq__(self, r)

	def __ne__(self, r: 'FloatWeightedSampleAccumulator') -> "bool":
	return _npstat.FloatWeightedSampleAccumulator___ne__(self, r)

	def __add__(self, r: 'FloatWeightedSampleAccumulator') -> "npstat::WeightedSampleAccumulator< float,long double >":
	return _npstat.FloatWeightedSampleAccumulator___add__(self, r)

	def scaleWeights(self, r: 'double') -> "npstat::WeightedSampleAccumulator< float,long double > &":
	return _npstat.FloatWeightedSampleAccumulator_scaleWeights(self, r)

	def reset(self) -> "void":
	return _npstat.FloatWeightedSampleAccumulator_reset(self)

	def reserve(self, n: 'unsigned long const') -> "void":
	return _npstat.FloatWeightedSampleAccumulator_reserve(self, n)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatWeightedSampleAccumulator_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatWeightedSampleAccumulator_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatWeightedSampleAccumulator_classname)
	else:
	classname = _npstat.FloatWeightedSampleAccumulator_classname
	if _newclass:
	version = staticmethod(_npstat.FloatWeightedSampleAccumulator_version)
	else:
	version = _npstat.FloatWeightedSampleAccumulator_version
	if _newclass:
	restore = staticmethod(_npstat.FloatWeightedSampleAccumulator_restore)
	else:
	restore = _npstat.FloatWeightedSampleAccumulator_restore

	def __mul__(self, r: 'double const') -> "npstat::WeightedSampleAccumulator< float,long double >":
	return _npstat.FloatWeightedSampleAccumulator___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::WeightedSampleAccumulator< float,long double >":
	return _npstat.FloatWeightedSampleAccumulator___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::WeightedSampleAccumulator< float,long double > &":
	return _npstat.FloatWeightedSampleAccumulator___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::WeightedSampleAccumulator< float,long double > &":
	return _npstat.FloatWeightedSampleAccumulator___idiv__(self, r)

	def __iadd__(self, *args) -> "npstat::WeightedSampleAccumulator< float,long double > &":
	return _npstat.FloatWeightedSampleAccumulator___iadd__(self, *args)

	def accumulate(self, *args) -> "void":
	return _npstat.FloatWeightedSampleAccumulator_accumulate(self, *args)
	__swig_destroy__ = _npstat.delete_FloatWeightedSampleAccumulator
	__del__ = lambda self: None
	FloatWeightedSampleAccumulator_swigregister = _npstat.FloatWeightedSampleAccumulator_swigregister
	FloatWeightedSampleAccumulator_swigregister(FloatWeightedSampleAccumulator)

	def FloatWeightedSampleAccumulator_classname() -> "char const *":
	return _npstat.FloatWeightedSampleAccumulator_classname()
	FloatWeightedSampleAccumulator_classname = _npstat.FloatWeightedSampleAccumulator_classname

	def FloatWeightedSampleAccumulator_version() -> "unsigned int":
	return _npstat.FloatWeightedSampleAccumulator_version()
	FloatWeightedSampleAccumulator_version = _npstat.FloatWeightedSampleAccumulator_version

	def FloatWeightedSampleAccumulator_restore(id: 'ClassId', arg3: 'istream', acc: 'FloatWeightedSampleAccumulator') -> "void":
	return _npstat.FloatWeightedSampleAccumulator_restore(id, arg3, acc)
	FloatWeightedSampleAccumulator_restore = _npstat.FloatWeightedSampleAccumulator_restore

	class DoubleWeightedSampleAccumulator(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleWeightedSampleAccumulator, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleWeightedSampleAccumulator, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_DoubleWeightedSampleAccumulator()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def maxWeight(self) -> "double":
	return _npstat.DoubleWeightedSampleAccumulator_maxWeight(self)

	def ncalls(self) -> "unsigned long":
	return _npstat.DoubleWeightedSampleAccumulator_ncalls(self)

	def nfills(self) -> "unsigned long":
	return _npstat.DoubleWeightedSampleAccumulator_nfills(self)

	def count(self) -> "double":
	return _npstat.DoubleWeightedSampleAccumulator_count(self)

	def min(self) -> "double":
	return _npstat.DoubleWeightedSampleAccumulator_min(self)

	def max(self) -> "double":
	return _npstat.DoubleWeightedSampleAccumulator_max(self)

	def mean(self) -> "long double":
	return _npstat.DoubleWeightedSampleAccumulator_mean(self)

	def stdev(self) -> "long double":
	return _npstat.DoubleWeightedSampleAccumulator_stdev(self)

	def meanUncertainty(self) -> "long double":
	return _npstat.DoubleWeightedSampleAccumulator_meanUncertainty(self)

	def median(self) -> "double":
	return _npstat.DoubleWeightedSampleAccumulator_median(self)

	def cdf(self, value: 'double') -> "double":
	return _npstat.DoubleWeightedSampleAccumulator_cdf(self, value)

	def weightBelow(self, value: 'double') -> "double":
	return _npstat.DoubleWeightedSampleAccumulator_weightBelow(self, value)

	def quantile(self, x: 'double') -> "double":
	return _npstat.DoubleWeightedSampleAccumulator_quantile(self, x)

	def location(self) -> "double":
	return _npstat.DoubleWeightedSampleAccumulator_location(self)

	def rangeDown(self) -> "double":
	return _npstat.DoubleWeightedSampleAccumulator_rangeDown(self)

	def rangeUp(self) -> "double":
	return _npstat.DoubleWeightedSampleAccumulator_rangeUp(self)

	def noThrowMean(self, valueIfNoData: 'long double const &') -> "long double":
	return _npstat.DoubleWeightedSampleAccumulator_noThrowMean(self, valueIfNoData)

	def noThrowStdev(self, valueIfNoData: 'long double const &') -> "long double":
	return _npstat.DoubleWeightedSampleAccumulator_noThrowStdev(self, valueIfNoData)

	def noThrowMeanUncertainty(self, valueIfNoData: 'long double const &') -> "long double":
	return _npstat.DoubleWeightedSampleAccumulator_noThrowMeanUncertainty(self, valueIfNoData)

	def averageWeight(self) -> "double":
	return _npstat.DoubleWeightedSampleAccumulator_averageWeight(self)

	def sumOfWeights(self) -> "double":
	return _npstat.DoubleWeightedSampleAccumulator_sumOfWeights(self)

	def data(self) -> "std::pair< double,double > const *":
	return _npstat.DoubleWeightedSampleAccumulator_data(self)

	def __eq__(self, r: 'DoubleWeightedSampleAccumulator') -> "bool":
	return _npstat.DoubleWeightedSampleAccumulator___eq__(self, r)

	def __ne__(self, r: 'DoubleWeightedSampleAccumulator') -> "bool":
	return _npstat.DoubleWeightedSampleAccumulator___ne__(self, r)

	def __add__(self, r: 'DoubleWeightedSampleAccumulator') -> "npstat::WeightedSampleAccumulator< double,long double >":
	return _npstat.DoubleWeightedSampleAccumulator___add__(self, r)

	def scaleWeights(self, r: 'double') -> "npstat::WeightedSampleAccumulator< double,long double > &":
	return _npstat.DoubleWeightedSampleAccumulator_scaleWeights(self, r)

	def reset(self) -> "void":
	return _npstat.DoubleWeightedSampleAccumulator_reset(self)

	def reserve(self, n: 'unsigned long const') -> "void":
	return _npstat.DoubleWeightedSampleAccumulator_reserve(self, n)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleWeightedSampleAccumulator_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleWeightedSampleAccumulator_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleWeightedSampleAccumulator_classname)
	else:
	classname = _npstat.DoubleWeightedSampleAccumulator_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleWeightedSampleAccumulator_version)
	else:
	version = _npstat.DoubleWeightedSampleAccumulator_version
	if _newclass:
	restore = staticmethod(_npstat.DoubleWeightedSampleAccumulator_restore)
	else:
	restore = _npstat.DoubleWeightedSampleAccumulator_restore

	def __mul__(self, r: 'double const') -> "npstat::WeightedSampleAccumulator< double,long double >":
	return _npstat.DoubleWeightedSampleAccumulator___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::WeightedSampleAccumulator< double,long double >":
	return _npstat.DoubleWeightedSampleAccumulator___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::WeightedSampleAccumulator< double,long double > &":
	return _npstat.DoubleWeightedSampleAccumulator___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::WeightedSampleAccumulator< double,long double > &":
	return _npstat.DoubleWeightedSampleAccumulator___idiv__(self, r)

	def __iadd__(self, *args) -> "npstat::WeightedSampleAccumulator< double,long double > &":
	return _npstat.DoubleWeightedSampleAccumulator___iadd__(self, *args)

	def accumulate(self, *args) -> "void":
	return _npstat.DoubleWeightedSampleAccumulator_accumulate(self, *args)
	__swig_destroy__ = _npstat.delete_DoubleWeightedSampleAccumulator
	__del__ = lambda self: None
	DoubleWeightedSampleAccumulator_swigregister = _npstat.DoubleWeightedSampleAccumulator_swigregister
	DoubleWeightedSampleAccumulator_swigregister(DoubleWeightedSampleAccumulator)

	def DoubleWeightedSampleAccumulator_classname() -> "char const *":
	return _npstat.DoubleWeightedSampleAccumulator_classname()
	DoubleWeightedSampleAccumulator_classname = _npstat.DoubleWeightedSampleAccumulator_classname

	def DoubleWeightedSampleAccumulator_version() -> "unsigned int":
	return _npstat.DoubleWeightedSampleAccumulator_version()
	DoubleWeightedSampleAccumulator_version = _npstat.DoubleWeightedSampleAccumulator_version

	def DoubleWeightedSampleAccumulator_restore(id: 'ClassId', arg3: 'istream', acc: 'DoubleWeightedSampleAccumulator') -> "void":
	return _npstat.DoubleWeightedSampleAccumulator_restore(id, arg3, acc)
	DoubleWeightedSampleAccumulator_restore = _npstat.DoubleWeightedSampleAccumulator_restore

	class BinSummary(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, BinSummary, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, BinSummary, name)
	__repr__ = _swig_repr

	def location(self) -> "double":
	return _npstat.BinSummary_location(self)

	def rangeDown(self) -> "double":
	return _npstat.BinSummary_rangeDown(self)

	def rangeUp(self) -> "double":
	return _npstat.BinSummary_rangeUp(self)

	def stdev(self) -> "double":
	return _npstat.BinSummary_stdev(self)

	def min(self) -> "double":
	return _npstat.BinSummary_min(self)

	def max(self) -> "double":
	return _npstat.BinSummary_max(self)

	def noThrowStdev(self, valueIfNoData: 'double'=0.0) -> "double":
	return _npstat.BinSummary_noThrowStdev(self, valueIfNoData)

	def noThrowMin(self, *args) -> "double":
	return _npstat.BinSummary_noThrowMin(self, *args)

	def noThrowMax(self, *args) -> "double":
	return _npstat.BinSummary_noThrowMax(self, *args)

	def hasStdev(self) -> "bool":
	return _npstat.BinSummary_hasStdev(self)

	def hasMin(self) -> "bool":
	return _npstat.BinSummary_hasMin(self)

	def hasMax(self) -> "bool":
	return _npstat.BinSummary_hasMax(self)

	def hasLimits(self) -> "bool":
	return _npstat.BinSummary_hasLimits(self)

	def setLocation(self, newValue: 'double') -> "void":
	return _npstat.BinSummary_setLocation(self, newValue)

	def setStdev(self, newValue: 'double') -> "void":
	return _npstat.BinSummary_setStdev(self, newValue)

	def setRangeDown(self, newValue: 'double') -> "void":
	return _npstat.BinSummary_setRangeDown(self, newValue)

	def setRangeUp(self, newValue: 'double') -> "void":
	return _npstat.BinSummary_setRangeUp(self, newValue)

	def setRanges(self, newRangeDown: 'double', newRangeUp: 'double') -> "void":
	return _npstat.BinSummary_setRanges(self, newRangeDown, newRangeUp)

	def setMin(self, newValue: 'double') -> "void":
	return _npstat.BinSummary_setMin(self, newValue)

	def setMax(self, newValue: 'double') -> "void":
	return _npstat.BinSummary_setMax(self, newValue)

	def setLimits(self, newMin: 'double', newMax: 'double') -> "void":
	return _npstat.BinSummary_setLimits(self, newMin, newMax)

	def setLocationAndLimits(self, newLocation: 'double', newMin: 'double', newMax: 'double') -> "void":
	return _npstat.BinSummary_setLocationAndLimits(self, newLocation, newMin, newMax)

	def shift(self, delta: 'double') -> "void":
	return _npstat.BinSummary_shift(self, delta)

	def scaleWidth(self, scale: 'double') -> "void":
	return _npstat.BinSummary_scaleWidth(self, scale)

	def symmetrizeRanges(self) -> "void":
	return _npstat.BinSummary_symmetrizeRanges(self)

	def __imul__(self, scaleFactor: 'double') -> "npstat::BinSummary &":
	return _npstat.BinSummary___imul__(self, scaleFactor)

	def __itruediv__(self, *args):
	return _npstat.BinSummary___itruediv__(self, *args)
	__idiv__ = __itruediv__



	def __mul__(self, r: 'double const') -> "npstat::BinSummary":
	return _npstat.BinSummary___mul__(self, r)

	def __truediv__(self, *args):
	return _npstat.BinSummary___truediv__(self, *args)
	__div__ = __truediv__



	def __iadd__(self, r: 'BinSummary') -> "npstat::BinSummary &":
	return _npstat.BinSummary___iadd__(self, r)

	def __isub__(self, r: 'BinSummary') -> "npstat::BinSummary &":
	return _npstat.BinSummary___isub__(self, r)

	def __add__(self, r: 'BinSummary') -> "npstat::BinSummary":
	return _npstat.BinSummary___add__(self, r)

	def __sub__(self, r: 'BinSummary') -> "npstat::BinSummary":
	return _npstat.BinSummary___sub__(self, r)

	def __eq__(self, r: 'BinSummary') -> "bool":
	return _npstat.BinSummary___eq__(self, r)

	def __ne__(self, r: 'BinSummary') -> "bool":
	return _npstat.BinSummary___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.BinSummary_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.BinSummary_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.BinSummary_classname)
	else:
	classname = _npstat.BinSummary_classname
	if _newclass:
	version = staticmethod(_npstat.BinSummary_version)
	else:
	version = _npstat.BinSummary_version
	if _newclass:
	restore = staticmethod(_npstat.BinSummary_restore)
	else:
	restore = _npstat.BinSummary_restore

	def __init__(self, *args):
	this = _npstat.new_BinSummary(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_BinSummary
	__del__ = lambda self: None
	BinSummary_swigregister = _npstat.BinSummary_swigregister
	BinSummary_swigregister(BinSummary)

	def BinSummary_classname() -> "char const *":
	return _npstat.BinSummary_classname()
	BinSummary_classname = _npstat.BinSummary_classname

	def BinSummary_version() -> "unsigned int":
	return _npstat.BinSummary_version()
	BinSummary_version = _npstat.BinSummary_version

	def BinSummary_restore(id: 'ClassId', arg3: 'istream', acc: 'BinSummary') -> "void":
	return _npstat.BinSummary_restore(id, arg3, acc)
	BinSummary_restore = _npstat.BinSummary_restore

	class StatAccArrayND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, StatAccArrayND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, StatAccArrayND, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_StatAccArrayND
	__del__ = lambda self: None

	def uninitialize(self) -> "npstat::ArrayND< npstat::StatAccumulator > &":
	return _npstat.StatAccArrayND_uninitialize(self)

	def reshape(self, *args) -> "npstat::ArrayND< npstat::StatAccumulator > &":
	return _npstat.StatAccArrayND_reshape(self, *args)

	def valueAt(self, *args) -> "npstat::StatAccumulator const &":
	return _npstat.StatAccArrayND_valueAt(self, *args)

	def linearPtr(self, *args) -> "npstat::StatAccumulator const &":
	return _npstat.StatAccArrayND_linearPtr(self, *args)

	def convertLinearIndex(self, l: 'unsigned long', index: 'unsigned int *', indexLen: 'unsigned int') -> "void":
	return _npstat.StatAccArrayND_convertLinearIndex(self, l, index, indexLen)

	def linearIndex(self, idx: 'unsigned int const *', idxLen: 'unsigned int') -> "unsigned long":
	return _npstat.StatAccArrayND_linearIndex(self, idx, idxLen)

	def length(self) -> "unsigned long":
	return _npstat.StatAccArrayND_length(self)

	def data(self) -> "npstat::StatAccumulator const *":
	return _npstat.StatAccArrayND_data(self)

	def isShapeKnown(self) -> "bool":
	return _npstat.StatAccArrayND_isShapeKnown(self)

	def rank(self) -> "unsigned int":
	return _npstat.StatAccArrayND_rank(self)

	def shape(self) -> "npstat::ArrayShape":
	return _npstat.StatAccArrayND_shape(self)

	def shapeData(self) -> "unsigned int const *":
	return _npstat.StatAccArrayND_shapeData(self)

	def fullRange(self) -> "npstat::ArrayRange":
	return _npstat.StatAccArrayND_fullRange(self)

	def span(self, dim: 'unsigned int') -> "unsigned int":
	return _npstat.StatAccArrayND_span(self, dim)

	def maximumSpan(self) -> "unsigned int":
	return _npstat.StatAccArrayND_maximumSpan(self)

	def minimumSpan(self) -> "unsigned int":
	return _npstat.StatAccArrayND_minimumSpan(self)

	def strides(self) -> "unsigned long const *":
	return _npstat.StatAccArrayND_strides(self)

	def isZero(self) -> "bool":
	return _npstat.StatAccArrayND_isZero(self)

	def __pos__(self) -> "npstat::ArrayND< npstat::StatAccumulator >":
	return _npstat.StatAccArrayND___pos__(self)

	def contract(self, pos1: 'unsigned int', pos2: 'unsigned int') -> "npstat::ArrayND< npstat::StatAccumulator >":
	return _npstat.StatAccArrayND_contract(self, pos1, pos2)

	def transpose(self, *args) -> "npstat::ArrayND< npstat::StatAccumulator >":
	return _npstat.StatAccArrayND_transpose(self, *args)

	def closestPtr(self, *args) -> "npstat::StatAccumulator const &":
	return _npstat.StatAccArrayND_closestPtr(self, *args)

	def constFill(self, c: 'StatAccumulator') -> "npstat::ArrayND< npstat::StatAccumulator > &":
	return _npstat.StatAccArrayND_constFill(self, c)

	def clear(self) -> "npstat::ArrayND< npstat::StatAccumulator > &":
	return _npstat.StatAccArrayND_clear(self)

	def isCompatible(self, *args) -> "bool":
	return _npstat.StatAccArrayND_isCompatible(self, *args)

	def sliceShape(self, fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayShape":
	return _npstat.StatAccArrayND_sliceShape(self, fixedIndices, nFixedIndices)

	def ptr(self, *args) -> "npstat::StatAccumulator const &":
	return _npstat.StatAccArrayND_ptr(self, *args)

	def clPtr(self, *args) -> "npstat::StatAccumulator const &":
	return _npstat.StatAccArrayND_clPtr(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.StatAccArrayND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.StatAccArrayND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.StatAccArrayND_classname)
	else:
	classname = _npstat.StatAccArrayND_classname
	if _newclass:
	version = staticmethod(_npstat.StatAccArrayND_version)
	else:
	version = _npstat.StatAccArrayND_version
	if _newclass:
	restore = staticmethod(_npstat.StatAccArrayND_restore)
	else:
	restore = _npstat.StatAccArrayND_restore

	def setValue(self, index: 'unsigned int const *', indexLen: 'unsigned int', v: 'StatAccumulator') -> "void":
	return _npstat.StatAccArrayND_setValue(self, index, indexLen, v)

	def value(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::StatAccumulator":
	return _npstat.StatAccArrayND_value(self, index, indexLen)

	def setLinearValue(self, index: 'unsigned long', v: 'StatAccumulator') -> "void":
	return _npstat.StatAccArrayND_setLinearValue(self, index, v)

	def linearValue(self, index: 'unsigned long') -> "npstat::StatAccumulator":
	return _npstat.StatAccArrayND_linearValue(self, index)

	def setClosest(self, x: 'double const *', xDim: 'unsigned int', v: 'StatAccumulator') -> "void":
	return _npstat.StatAccArrayND_setClosest(self, x, xDim, v)

	def closest(self, x: 'double const *', xDim: 'unsigned int') -> "npstat::StatAccumulator const":
	return _npstat.StatAccArrayND_closest(self, x, xDim)

	def set(self, *args) -> "void":
	return _npstat.StatAccArrayND_set(self, *args)

	def __call__(self, *args) -> "npstat::StatAccumulator":
	return _npstat.StatAccArrayND___call__(self, *args)

	def setCl(self, *args) -> "void":
	return _npstat.StatAccArrayND_setCl(self, *args)

	def cl(self, *args) -> "npstat::StatAccumulator":
	return _npstat.StatAccArrayND_cl(self, *args)

	def setData(self, data: 'StatAccumulator', dataLength: 'unsigned long') -> "void":
	return _npstat.StatAccArrayND_setData(self, data, dataLength)

	def __eq__(self, r: 'StatAccArrayND') -> "bool":
	return _npstat.StatAccArrayND___eq__(self, r)

	def __ne__(self, r: 'StatAccArrayND') -> "bool":
	return _npstat.StatAccArrayND___ne__(self, r)

	def __add__(self, r: 'StatAccArrayND') -> "npstat::ArrayND< npstat::StatAccumulator >":
	return _npstat.StatAccArrayND___add__(self, r)

	def __mul__(self, r: 'double const') -> "npstat::ArrayND< npstat::StatAccumulator >":
	return _npstat.StatAccArrayND___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::ArrayND< npstat::StatAccumulator >":
	return _npstat.StatAccArrayND___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::ArrayND< npstat::StatAccumulator > &":
	return _npstat.StatAccArrayND___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::ArrayND< npstat::StatAccumulator > &":
	return _npstat.StatAccArrayND___idiv__(self, r)

	def __iadd__(self, r: 'StatAccArrayND') -> "npstat::ArrayND< npstat::StatAccumulator > &":
	return _npstat.StatAccArrayND___iadd__(self, r)

	def addmul(self, r: 'StatAccArrayND', c: 'double const') -> "npstat::ArrayND< npstat::StatAccumulator > &":
	return _npstat.StatAccArrayND_addmul(self, r, c)

	def marginalize(self, r: 'npstat::ArrayND< npstat::ArrayND< npstat::StatAccumulator,1U,10U >::proper_double > const &', indexMap: 'unsigned int const *', mapLen: 'unsigned int const') -> "npstat::ArrayND< npstat::StatAccumulator >":
	return _npstat.StatAccArrayND_marginalize(self, r, indexMap, mapLen)

	def sum(self) -> "npstat::StatAccumulator":
	return _npstat.StatAccArrayND_sum(self)

	def cdfValue(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::StatAccumulator":
	return _npstat.StatAccArrayND_cdfValue(self, index, indexLen)

	def isShapeCompatible(self, r: 'StatAccArrayND') -> "bool":
	return _npstat.StatAccArrayND_isShapeCompatible(self, r)

	def exportSlice(self, slice: 'StatAccArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.StatAccArrayND_exportSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def exportMemSlice(self, slice: 'StatAccumulator', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.StatAccArrayND_exportMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def importSlice(self, slice: 'StatAccArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.StatAccArrayND_importSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def importMemSlice(self, slice: 'StatAccumulator', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.StatAccArrayND_importMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def multiplyBySlice(self, slice: 'npstat::ArrayND< npstat::ArrayND< npstat::StatAccumulator,1U,10U >::proper_double > const &', fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayND< npstat::StatAccumulator > &":
	return _npstat.StatAccArrayND_multiplyBySlice(self, slice, fixedIndices, nFixedIndices)

	def subrange(self, range: 'ArrayRange') -> "npstat::ArrayND< npstat::StatAccumulator >":
	return _npstat.StatAccArrayND_subrange(self, range)

	def slice(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::ArrayND< npstat::StatAccumulator >":
	return _npstat.StatAccArrayND_slice(self, index, indexLen)

	def rotate(self, shifts: 'unsigned int const *', lenShifts: 'unsigned int', rotated: 'StatAccArrayND') -> "void":
	return _npstat.StatAccArrayND_rotate(self, shifts, lenShifts, rotated)

	def exportSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', to: 'StatAccArrayND') -> "void":
	return _npstat.StatAccArrayND_exportSubrange(self, corner, lenCorner, to)

	def importSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', arg4: 'StatAccArrayND') -> "void":
	return _npstat.StatAccArrayND_importSubrange(self, corner, lenCorner, arg4)

	def multiMirror(self, out: 'StatAccArrayND') -> "void":
	return _npstat.StatAccArrayND_multiMirror(self, out)

	def __init__(self, *args):
	this = _npstat.new_StatAccArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	StatAccArrayND_swigregister = _npstat.StatAccArrayND_swigregister
	StatAccArrayND_swigregister(StatAccArrayND)

	def StatAccArrayND_classname() -> "char const *":
	return _npstat.StatAccArrayND_classname()
	StatAccArrayND_classname = _npstat.StatAccArrayND_classname

	def StatAccArrayND_version() -> "unsigned int":
	return _npstat.StatAccArrayND_version()
	StatAccArrayND_version = _npstat.StatAccArrayND_version

	def StatAccArrayND_restore(id: 'ClassId', arg3: 'istream', array: 'StatAccArrayND') -> "void":
	return _npstat.StatAccArrayND_restore(id, arg3, array)
	StatAccArrayND_restore = _npstat.StatAccArrayND_restore

	class WStatAccArrayND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, WStatAccArrayND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, WStatAccArrayND, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_WStatAccArrayND
	__del__ = lambda self: None

	def uninitialize(self) -> "npstat::ArrayND< npstat::WeightedStatAccumulator > &":
	return _npstat.WStatAccArrayND_uninitialize(self)

	def reshape(self, *args) -> "npstat::ArrayND< npstat::WeightedStatAccumulator > &":
	return _npstat.WStatAccArrayND_reshape(self, *args)

	def valueAt(self, *args) -> "npstat::WeightedStatAccumulator const &":
	return _npstat.WStatAccArrayND_valueAt(self, *args)

	def linearPtr(self, *args) -> "npstat::WeightedStatAccumulator const &":
	return _npstat.WStatAccArrayND_linearPtr(self, *args)

	def convertLinearIndex(self, l: 'unsigned long', index: 'unsigned int *', indexLen: 'unsigned int') -> "void":
	return _npstat.WStatAccArrayND_convertLinearIndex(self, l, index, indexLen)

	def linearIndex(self, idx: 'unsigned int const *', idxLen: 'unsigned int') -> "unsigned long":
	return _npstat.WStatAccArrayND_linearIndex(self, idx, idxLen)

	def length(self) -> "unsigned long":
	return _npstat.WStatAccArrayND_length(self)

	def data(self) -> "npstat::WeightedStatAccumulator const *":
	return _npstat.WStatAccArrayND_data(self)

	def isShapeKnown(self) -> "bool":
	return _npstat.WStatAccArrayND_isShapeKnown(self)

	def rank(self) -> "unsigned int":
	return _npstat.WStatAccArrayND_rank(self)

	def shape(self) -> "npstat::ArrayShape":
	return _npstat.WStatAccArrayND_shape(self)

	def shapeData(self) -> "unsigned int const *":
	return _npstat.WStatAccArrayND_shapeData(self)

	def fullRange(self) -> "npstat::ArrayRange":
	return _npstat.WStatAccArrayND_fullRange(self)

	def span(self, dim: 'unsigned int') -> "unsigned int":
	return _npstat.WStatAccArrayND_span(self, dim)

	def maximumSpan(self) -> "unsigned int":
	return _npstat.WStatAccArrayND_maximumSpan(self)

	def minimumSpan(self) -> "unsigned int":
	return _npstat.WStatAccArrayND_minimumSpan(self)

	def strides(self) -> "unsigned long const *":
	return _npstat.WStatAccArrayND_strides(self)

	def isZero(self) -> "bool":
	return _npstat.WStatAccArrayND_isZero(self)

	def __pos__(self) -> "npstat::ArrayND< npstat::WeightedStatAccumulator >":
	return _npstat.WStatAccArrayND___pos__(self)

	def contract(self, pos1: 'unsigned int', pos2: 'unsigned int') -> "npstat::ArrayND< npstat::WeightedStatAccumulator >":
	return _npstat.WStatAccArrayND_contract(self, pos1, pos2)

	def transpose(self, *args) -> "npstat::ArrayND< npstat::WeightedStatAccumulator >":
	return _npstat.WStatAccArrayND_transpose(self, *args)

	def closestPtr(self, *args) -> "npstat::WeightedStatAccumulator const &":
	return _npstat.WStatAccArrayND_closestPtr(self, *args)

	def constFill(self, c: 'WeightedStatAccumulator') -> "npstat::ArrayND< npstat::WeightedStatAccumulator > &":
	return _npstat.WStatAccArrayND_constFill(self, c)

	def clear(self) -> "npstat::ArrayND< npstat::WeightedStatAccumulator > &":
	return _npstat.WStatAccArrayND_clear(self)

	def isCompatible(self, *args) -> "bool":
	return _npstat.WStatAccArrayND_isCompatible(self, *args)

	def sliceShape(self, fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayShape":
	return _npstat.WStatAccArrayND_sliceShape(self, fixedIndices, nFixedIndices)

	def ptr(self, *args) -> "npstat::WeightedStatAccumulator const &":
	return _npstat.WStatAccArrayND_ptr(self, *args)

	def clPtr(self, *args) -> "npstat::WeightedStatAccumulator const &":
	return _npstat.WStatAccArrayND_clPtr(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.WStatAccArrayND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.WStatAccArrayND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.WStatAccArrayND_classname)
	else:
	classname = _npstat.WStatAccArrayND_classname
	if _newclass:
	version = staticmethod(_npstat.WStatAccArrayND_version)
	else:
	version = _npstat.WStatAccArrayND_version
	if _newclass:
	restore = staticmethod(_npstat.WStatAccArrayND_restore)
	else:
	restore = _npstat.WStatAccArrayND_restore

	def setValue(self, index: 'unsigned int const *', indexLen: 'unsigned int', v: 'WeightedStatAccumulator') -> "void":
	return _npstat.WStatAccArrayND_setValue(self, index, indexLen, v)

	def value(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::WeightedStatAccumulator":
	return _npstat.WStatAccArrayND_value(self, index, indexLen)

	def setLinearValue(self, index: 'unsigned long', v: 'WeightedStatAccumulator') -> "void":
	return _npstat.WStatAccArrayND_setLinearValue(self, index, v)

	def linearValue(self, index: 'unsigned long') -> "npstat::WeightedStatAccumulator":
	return _npstat.WStatAccArrayND_linearValue(self, index)

	def setClosest(self, x: 'double const *', xDim: 'unsigned int', v: 'WeightedStatAccumulator') -> "void":
	return _npstat.WStatAccArrayND_setClosest(self, x, xDim, v)

	def closest(self, x: 'double const *', xDim: 'unsigned int') -> "npstat::WeightedStatAccumulator const":
	return _npstat.WStatAccArrayND_closest(self, x, xDim)

	def set(self, *args) -> "void":
	return _npstat.WStatAccArrayND_set(self, *args)

	def __call__(self, *args) -> "npstat::WeightedStatAccumulator":
	return _npstat.WStatAccArrayND___call__(self, *args)

	def setCl(self, *args) -> "void":
	return _npstat.WStatAccArrayND_setCl(self, *args)

	def cl(self, *args) -> "npstat::WeightedStatAccumulator":
	return _npstat.WStatAccArrayND_cl(self, *args)

	def setData(self, data: 'WeightedStatAccumulator', dataLength: 'unsigned long') -> "void":
	return _npstat.WStatAccArrayND_setData(self, data, dataLength)

	def __eq__(self, r: 'WStatAccArrayND') -> "bool":
	return _npstat.WStatAccArrayND___eq__(self, r)

	def __ne__(self, r: 'WStatAccArrayND') -> "bool":
	return _npstat.WStatAccArrayND___ne__(self, r)

	def __add__(self, r: 'WStatAccArrayND') -> "npstat::ArrayND< npstat::WeightedStatAccumulator >":
	return _npstat.WStatAccArrayND___add__(self, r)

	def __mul__(self, r: 'double const') -> "npstat::ArrayND< npstat::WeightedStatAccumulator >":
	return _npstat.WStatAccArrayND___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::ArrayND< npstat::WeightedStatAccumulator >":
	return _npstat.WStatAccArrayND___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::ArrayND< npstat::WeightedStatAccumulator > &":
	return _npstat.WStatAccArrayND___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::ArrayND< npstat::WeightedStatAccumulator > &":
	return _npstat.WStatAccArrayND___idiv__(self, r)

	def __iadd__(self, r: 'WStatAccArrayND') -> "npstat::ArrayND< npstat::WeightedStatAccumulator > &":
	return _npstat.WStatAccArrayND___iadd__(self, r)

	def addmul(self, r: 'WStatAccArrayND', c: 'double const') -> "npstat::ArrayND< npstat::WeightedStatAccumulator > &":
	return _npstat.WStatAccArrayND_addmul(self, r, c)

	def marginalize(self, r: 'npstat::ArrayND< npstat::ArrayND< npstat::WeightedStatAccumulator,1U,10U >::proper_double > const &', indexMap: 'unsigned int const *', mapLen: 'unsigned int const') -> "npstat::ArrayND< npstat::WeightedStatAccumulator >":
	return _npstat.WStatAccArrayND_marginalize(self, r, indexMap, mapLen)

	def sum(self) -> "npstat::WeightedStatAccumulator":
	return _npstat.WStatAccArrayND_sum(self)

	def cdfValue(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::WeightedStatAccumulator":
	return _npstat.WStatAccArrayND_cdfValue(self, index, indexLen)

	def isShapeCompatible(self, r: 'WStatAccArrayND') -> "bool":
	return _npstat.WStatAccArrayND_isShapeCompatible(self, r)

	def exportSlice(self, slice: 'WStatAccArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.WStatAccArrayND_exportSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def exportMemSlice(self, slice: 'WeightedStatAccumulator', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.WStatAccArrayND_exportMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def importSlice(self, slice: 'WStatAccArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.WStatAccArrayND_importSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def importMemSlice(self, slice: 'WeightedStatAccumulator', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.WStatAccArrayND_importMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def multiplyBySlice(self, slice: 'npstat::ArrayND< npstat::ArrayND< npstat::WeightedStatAccumulator,1U,10U >::proper_double > const &', fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayND< npstat::WeightedStatAccumulator > &":
	return _npstat.WStatAccArrayND_multiplyBySlice(self, slice, fixedIndices, nFixedIndices)

	def subrange(self, range: 'ArrayRange') -> "npstat::ArrayND< npstat::WeightedStatAccumulator >":
	return _npstat.WStatAccArrayND_subrange(self, range)

	def slice(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::ArrayND< npstat::WeightedStatAccumulator >":
	return _npstat.WStatAccArrayND_slice(self, index, indexLen)

	def rotate(self, shifts: 'unsigned int const *', lenShifts: 'unsigned int', rotated: 'WStatAccArrayND') -> "void":
	return _npstat.WStatAccArrayND_rotate(self, shifts, lenShifts, rotated)

	def exportSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', to: 'WStatAccArrayND') -> "void":
	return _npstat.WStatAccArrayND_exportSubrange(self, corner, lenCorner, to)

	def importSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', arg4: 'WStatAccArrayND') -> "void":
	return _npstat.WStatAccArrayND_importSubrange(self, corner, lenCorner, arg4)

	def multiMirror(self, out: 'WStatAccArrayND') -> "void":
	return _npstat.WStatAccArrayND_multiMirror(self, out)

	def __init__(self, *args):
	this = _npstat.new_WStatAccArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	WStatAccArrayND_swigregister = _npstat.WStatAccArrayND_swigregister
	WStatAccArrayND_swigregister(WStatAccArrayND)

	def WStatAccArrayND_classname() -> "char const *":
	return _npstat.WStatAccArrayND_classname()
	WStatAccArrayND_classname = _npstat.WStatAccArrayND_classname

	def WStatAccArrayND_version() -> "unsigned int":
	return _npstat.WStatAccArrayND_version()
	WStatAccArrayND_version = _npstat.WStatAccArrayND_version

	def WStatAccArrayND_restore(id: 'ClassId', arg3: 'istream', array: 'WStatAccArrayND') -> "void":
	return _npstat.WStatAccArrayND_restore(id, arg3, array)
	WStatAccArrayND_restore = _npstat.WStatAccArrayND_restore

	class FSampleAccArrayND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FSampleAccArrayND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FSampleAccArrayND, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FSampleAccArrayND
	__del__ = lambda self: None

	def uninitialize(self) -> "npstat::ArrayND< npstat::FloatSampleAccumulator > &":
	return _npstat.FSampleAccArrayND_uninitialize(self)

	def reshape(self, *args) -> "npstat::ArrayND< npstat::FloatSampleAccumulator > &":
	return _npstat.FSampleAccArrayND_reshape(self, *args)

	def valueAt(self, *args) -> "npstat::SampleAccumulator< float,long double > const &":
	return _npstat.FSampleAccArrayND_valueAt(self, *args)

	def linearPtr(self, *args) -> "npstat::SampleAccumulator< float,long double > const &":
	return _npstat.FSampleAccArrayND_linearPtr(self, *args)

	def convertLinearIndex(self, l: 'unsigned long', index: 'unsigned int *', indexLen: 'unsigned int') -> "void":
	return _npstat.FSampleAccArrayND_convertLinearIndex(self, l, index, indexLen)

	def linearIndex(self, idx: 'unsigned int const *', idxLen: 'unsigned int') -> "unsigned long":
	return _npstat.FSampleAccArrayND_linearIndex(self, idx, idxLen)

	def length(self) -> "unsigned long":
	return _npstat.FSampleAccArrayND_length(self)

	def data(self) -> "npstat::SampleAccumulator< float,long double > const *":
	return _npstat.FSampleAccArrayND_data(self)

	def isShapeKnown(self) -> "bool":
	return _npstat.FSampleAccArrayND_isShapeKnown(self)

	def rank(self) -> "unsigned int":
	return _npstat.FSampleAccArrayND_rank(self)

	def shape(self) -> "npstat::ArrayShape":
	return _npstat.FSampleAccArrayND_shape(self)

	def shapeData(self) -> "unsigned int const *":
	return _npstat.FSampleAccArrayND_shapeData(self)

	def fullRange(self) -> "npstat::ArrayRange":
	return _npstat.FSampleAccArrayND_fullRange(self)

	def span(self, dim: 'unsigned int') -> "unsigned int":
	return _npstat.FSampleAccArrayND_span(self, dim)

	def maximumSpan(self) -> "unsigned int":
	return _npstat.FSampleAccArrayND_maximumSpan(self)

	def minimumSpan(self) -> "unsigned int":
	return _npstat.FSampleAccArrayND_minimumSpan(self)

	def strides(self) -> "unsigned long const *":
	return _npstat.FSampleAccArrayND_strides(self)

	def isZero(self) -> "bool":
	return _npstat.FSampleAccArrayND_isZero(self)

	def __pos__(self) -> "npstat::ArrayND< npstat::FloatSampleAccumulator >":
	return _npstat.FSampleAccArrayND___pos__(self)

	def contract(self, pos1: 'unsigned int', pos2: 'unsigned int') -> "npstat::ArrayND< npstat::FloatSampleAccumulator >":
	return _npstat.FSampleAccArrayND_contract(self, pos1, pos2)

	def transpose(self, *args) -> "npstat::ArrayND< npstat::FloatSampleAccumulator >":
	return _npstat.FSampleAccArrayND_transpose(self, *args)

	def closestPtr(self, *args) -> "npstat::SampleAccumulator< float,long double > const &":
	return _npstat.FSampleAccArrayND_closestPtr(self, *args)

	def constFill(self, c: 'FloatSampleAccumulator') -> "npstat::ArrayND< npstat::FloatSampleAccumulator > &":
	return _npstat.FSampleAccArrayND_constFill(self, c)

	def clear(self) -> "npstat::ArrayND< npstat::FloatSampleAccumulator > &":
	return _npstat.FSampleAccArrayND_clear(self)

	def isCompatible(self, *args) -> "bool":
	return _npstat.FSampleAccArrayND_isCompatible(self, *args)

	def sliceShape(self, fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayShape":
	return _npstat.FSampleAccArrayND_sliceShape(self, fixedIndices, nFixedIndices)

	def ptr(self, *args) -> "npstat::SampleAccumulator< float,long double > const &":
	return _npstat.FSampleAccArrayND_ptr(self, *args)

	def clPtr(self, *args) -> "npstat::SampleAccumulator< float,long double > const &":
	return _npstat.FSampleAccArrayND_clPtr(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.FSampleAccArrayND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FSampleAccArrayND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FSampleAccArrayND_classname)
	else:
	classname = _npstat.FSampleAccArrayND_classname
	if _newclass:
	version = staticmethod(_npstat.FSampleAccArrayND_version)
	else:
	version = _npstat.FSampleAccArrayND_version
	if _newclass:
	restore = staticmethod(_npstat.FSampleAccArrayND_restore)
	else:
	restore = _npstat.FSampleAccArrayND_restore

	def setValue(self, index: 'unsigned int const *', indexLen: 'unsigned int', v: 'FloatSampleAccumulator') -> "void":
	return _npstat.FSampleAccArrayND_setValue(self, index, indexLen, v)

	def value(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::SampleAccumulator< float,long double >":
	return _npstat.FSampleAccArrayND_value(self, index, indexLen)

	def setLinearValue(self, index: 'unsigned long', v: 'FloatSampleAccumulator') -> "void":
	return _npstat.FSampleAccArrayND_setLinearValue(self, index, v)

	def linearValue(self, index: 'unsigned long') -> "npstat::SampleAccumulator< float,long double >":
	return _npstat.FSampleAccArrayND_linearValue(self, index)

	def setClosest(self, x: 'double const *', xDim: 'unsigned int', v: 'FloatSampleAccumulator') -> "void":
	return _npstat.FSampleAccArrayND_setClosest(self, x, xDim, v)

	def closest(self, x: 'double const *', xDim: 'unsigned int') -> "npstat::SampleAccumulator< float,long double > const":
	return _npstat.FSampleAccArrayND_closest(self, x, xDim)

	def set(self, *args) -> "void":
	return _npstat.FSampleAccArrayND_set(self, *args)

	def __call__(self, *args) -> "npstat::SampleAccumulator< float,long double >":
	return _npstat.FSampleAccArrayND___call__(self, *args)

	def setCl(self, *args) -> "void":
	return _npstat.FSampleAccArrayND_setCl(self, *args)

	def cl(self, *args) -> "npstat::SampleAccumulator< float,long double >":
	return _npstat.FSampleAccArrayND_cl(self, *args)

	def setData(self, data: 'FloatSampleAccumulator', dataLength: 'unsigned long') -> "void":
	return _npstat.FSampleAccArrayND_setData(self, data, dataLength)

	def __eq__(self, r: 'FSampleAccArrayND') -> "bool":
	return _npstat.FSampleAccArrayND___eq__(self, r)

	def __ne__(self, r: 'FSampleAccArrayND') -> "bool":
	return _npstat.FSampleAccArrayND___ne__(self, r)

	def __add__(self, r: 'FSampleAccArrayND') -> "npstat::ArrayND< npstat::FloatSampleAccumulator >":
	return _npstat.FSampleAccArrayND___add__(self, r)

	def __mul__(self, r: 'double const') -> "npstat::ArrayND< npstat::FloatSampleAccumulator >":
	return _npstat.FSampleAccArrayND___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::ArrayND< npstat::FloatSampleAccumulator >":
	return _npstat.FSampleAccArrayND___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::ArrayND< npstat::FloatSampleAccumulator > &":
	return _npstat.FSampleAccArrayND___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::ArrayND< npstat::FloatSampleAccumulator > &":
	return _npstat.FSampleAccArrayND___idiv__(self, r)

	def __iadd__(self, r: 'FSampleAccArrayND') -> "npstat::ArrayND< npstat::FloatSampleAccumulator > &":
	return _npstat.FSampleAccArrayND___iadd__(self, r)

	def addmul(self, r: 'FSampleAccArrayND', c: 'double const') -> "npstat::ArrayND< npstat::FloatSampleAccumulator > &":
	return _npstat.FSampleAccArrayND_addmul(self, r, c)

	def marginalize(self, r: 'npstat::ArrayND< npstat::ArrayND< npstat::FloatSampleAccumulator,1U,10U >::proper_double > const &', indexMap: 'unsigned int const *', mapLen: 'unsigned int const') -> "npstat::ArrayND< npstat::FloatSampleAccumulator >":
	return _npstat.FSampleAccArrayND_marginalize(self, r, indexMap, mapLen)

	def sum(self) -> "npstat::SampleAccumulator< float,long double >":
	return _npstat.FSampleAccArrayND_sum(self)

	def cdfValue(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::SampleAccumulator< float,long double >":
	return _npstat.FSampleAccArrayND_cdfValue(self, index, indexLen)

	def isShapeCompatible(self, r: 'FSampleAccArrayND') -> "bool":
	return _npstat.FSampleAccArrayND_isShapeCompatible(self, r)

	def exportSlice(self, slice: 'FSampleAccArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.FSampleAccArrayND_exportSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def exportMemSlice(self, slice: 'FloatSampleAccumulator', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.FSampleAccArrayND_exportMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def importSlice(self, slice: 'FSampleAccArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.FSampleAccArrayND_importSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def importMemSlice(self, slice: 'FloatSampleAccumulator', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.FSampleAccArrayND_importMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def multiplyBySlice(self, slice: 'npstat::ArrayND< npstat::ArrayND< npstat::FloatSampleAccumulator,1U,10U >::proper_double > const &', fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayND< npstat::FloatSampleAccumulator > &":
	return _npstat.FSampleAccArrayND_multiplyBySlice(self, slice, fixedIndices, nFixedIndices)

	def subrange(self, range: 'ArrayRange') -> "npstat::ArrayND< npstat::FloatSampleAccumulator >":
	return _npstat.FSampleAccArrayND_subrange(self, range)

	def slice(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::ArrayND< npstat::FloatSampleAccumulator >":
	return _npstat.FSampleAccArrayND_slice(self, index, indexLen)

	def rotate(self, shifts: 'unsigned int const *', lenShifts: 'unsigned int', rotated: 'FSampleAccArrayND') -> "void":
	return _npstat.FSampleAccArrayND_rotate(self, shifts, lenShifts, rotated)

	def exportSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', to: 'FSampleAccArrayND') -> "void":
	return _npstat.FSampleAccArrayND_exportSubrange(self, corner, lenCorner, to)

	def importSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', arg4: 'FSampleAccArrayND') -> "void":
	return _npstat.FSampleAccArrayND_importSubrange(self, corner, lenCorner, arg4)

	def multiMirror(self, out: 'FSampleAccArrayND') -> "void":
	return _npstat.FSampleAccArrayND_multiMirror(self, out)

	def __init__(self, *args):
	this = _npstat.new_FSampleAccArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	FSampleAccArrayND_swigregister = _npstat.FSampleAccArrayND_swigregister
	FSampleAccArrayND_swigregister(FSampleAccArrayND)

	def FSampleAccArrayND_classname() -> "char const *":
	return _npstat.FSampleAccArrayND_classname()
	FSampleAccArrayND_classname = _npstat.FSampleAccArrayND_classname

	def FSampleAccArrayND_version() -> "unsigned int":
	return _npstat.FSampleAccArrayND_version()
	FSampleAccArrayND_version = _npstat.FSampleAccArrayND_version

	def FSampleAccArrayND_restore(id: 'ClassId', arg3: 'istream', array: 'FSampleAccArrayND') -> "void":
	return _npstat.FSampleAccArrayND_restore(id, arg3, array)
	FSampleAccArrayND_restore = _npstat.FSampleAccArrayND_restore

	class DSampleAccArrayND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DSampleAccArrayND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DSampleAccArrayND, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DSampleAccArrayND
	__del__ = lambda self: None

	def uninitialize(self) -> "npstat::ArrayND< npstat::DoubleSampleAccumulator > &":
	return _npstat.DSampleAccArrayND_uninitialize(self)

	def reshape(self, *args) -> "npstat::ArrayND< npstat::DoubleSampleAccumulator > &":
	return _npstat.DSampleAccArrayND_reshape(self, *args)

	def valueAt(self, *args) -> "npstat::SampleAccumulator< double,long double > const &":
	return _npstat.DSampleAccArrayND_valueAt(self, *args)

	def linearPtr(self, *args) -> "npstat::SampleAccumulator< double,long double > const &":
	return _npstat.DSampleAccArrayND_linearPtr(self, *args)

	def convertLinearIndex(self, l: 'unsigned long', index: 'unsigned int *', indexLen: 'unsigned int') -> "void":
	return _npstat.DSampleAccArrayND_convertLinearIndex(self, l, index, indexLen)

	def linearIndex(self, idx: 'unsigned int const *', idxLen: 'unsigned int') -> "unsigned long":
	return _npstat.DSampleAccArrayND_linearIndex(self, idx, idxLen)

	def length(self) -> "unsigned long":
	return _npstat.DSampleAccArrayND_length(self)

	def data(self) -> "npstat::SampleAccumulator< double,long double > const *":
	return _npstat.DSampleAccArrayND_data(self)

	def isShapeKnown(self) -> "bool":
	return _npstat.DSampleAccArrayND_isShapeKnown(self)

	def rank(self) -> "unsigned int":
	return _npstat.DSampleAccArrayND_rank(self)

	def shape(self) -> "npstat::ArrayShape":
	return _npstat.DSampleAccArrayND_shape(self)

	def shapeData(self) -> "unsigned int const *":
	return _npstat.DSampleAccArrayND_shapeData(self)

	def fullRange(self) -> "npstat::ArrayRange":
	return _npstat.DSampleAccArrayND_fullRange(self)

	def span(self, dim: 'unsigned int') -> "unsigned int":
	return _npstat.DSampleAccArrayND_span(self, dim)

	def maximumSpan(self) -> "unsigned int":
	return _npstat.DSampleAccArrayND_maximumSpan(self)

	def minimumSpan(self) -> "unsigned int":
	return _npstat.DSampleAccArrayND_minimumSpan(self)

	def strides(self) -> "unsigned long const *":
	return _npstat.DSampleAccArrayND_strides(self)

	def isZero(self) -> "bool":
	return _npstat.DSampleAccArrayND_isZero(self)

	def __pos__(self) -> "npstat::ArrayND< npstat::DoubleSampleAccumulator >":
	return _npstat.DSampleAccArrayND___pos__(self)

	def contract(self, pos1: 'unsigned int', pos2: 'unsigned int') -> "npstat::ArrayND< npstat::DoubleSampleAccumulator >":
	return _npstat.DSampleAccArrayND_contract(self, pos1, pos2)

	def transpose(self, *args) -> "npstat::ArrayND< npstat::DoubleSampleAccumulator >":
	return _npstat.DSampleAccArrayND_transpose(self, *args)

	def closestPtr(self, *args) -> "npstat::SampleAccumulator< double,long double > const &":
	return _npstat.DSampleAccArrayND_closestPtr(self, *args)

	def constFill(self, c: 'DoubleSampleAccumulator') -> "npstat::ArrayND< npstat::DoubleSampleAccumulator > &":
	return _npstat.DSampleAccArrayND_constFill(self, c)

	def clear(self) -> "npstat::ArrayND< npstat::DoubleSampleAccumulator > &":
	return _npstat.DSampleAccArrayND_clear(self)

	def isCompatible(self, *args) -> "bool":
	return _npstat.DSampleAccArrayND_isCompatible(self, *args)

	def sliceShape(self, fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayShape":
	return _npstat.DSampleAccArrayND_sliceShape(self, fixedIndices, nFixedIndices)

	def ptr(self, *args) -> "npstat::SampleAccumulator< double,long double > const &":
	return _npstat.DSampleAccArrayND_ptr(self, *args)

	def clPtr(self, *args) -> "npstat::SampleAccumulator< double,long double > const &":
	return _npstat.DSampleAccArrayND_clPtr(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.DSampleAccArrayND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DSampleAccArrayND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DSampleAccArrayND_classname)
	else:
	classname = _npstat.DSampleAccArrayND_classname
	if _newclass:
	version = staticmethod(_npstat.DSampleAccArrayND_version)
	else:
	version = _npstat.DSampleAccArrayND_version
	if _newclass:
	restore = staticmethod(_npstat.DSampleAccArrayND_restore)
	else:
	restore = _npstat.DSampleAccArrayND_restore

	def setValue(self, index: 'unsigned int const *', indexLen: 'unsigned int', v: 'DoubleSampleAccumulator') -> "void":
	return _npstat.DSampleAccArrayND_setValue(self, index, indexLen, v)

	def value(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::SampleAccumulator< double,long double >":
	return _npstat.DSampleAccArrayND_value(self, index, indexLen)

	def setLinearValue(self, index: 'unsigned long', v: 'DoubleSampleAccumulator') -> "void":
	return _npstat.DSampleAccArrayND_setLinearValue(self, index, v)

	def linearValue(self, index: 'unsigned long') -> "npstat::SampleAccumulator< double,long double >":
	return _npstat.DSampleAccArrayND_linearValue(self, index)

	def setClosest(self, x: 'double const *', xDim: 'unsigned int', v: 'DoubleSampleAccumulator') -> "void":
	return _npstat.DSampleAccArrayND_setClosest(self, x, xDim, v)

	def closest(self, x: 'double const *', xDim: 'unsigned int') -> "npstat::SampleAccumulator< double,long double > const":
	return _npstat.DSampleAccArrayND_closest(self, x, xDim)

	def set(self, *args) -> "void":
	return _npstat.DSampleAccArrayND_set(self, *args)

	def __call__(self, *args) -> "npstat::SampleAccumulator< double,long double >":
	return _npstat.DSampleAccArrayND___call__(self, *args)

	def setCl(self, *args) -> "void":
	return _npstat.DSampleAccArrayND_setCl(self, *args)

	def cl(self, *args) -> "npstat::SampleAccumulator< double,long double >":
	return _npstat.DSampleAccArrayND_cl(self, *args)

	def setData(self, data: 'DoubleSampleAccumulator', dataLength: 'unsigned long') -> "void":
	return _npstat.DSampleAccArrayND_setData(self, data, dataLength)

	def __eq__(self, r: 'DSampleAccArrayND') -> "bool":
	return _npstat.DSampleAccArrayND___eq__(self, r)

	def __ne__(self, r: 'DSampleAccArrayND') -> "bool":
	return _npstat.DSampleAccArrayND___ne__(self, r)

	def __add__(self, r: 'DSampleAccArrayND') -> "npstat::ArrayND< npstat::DoubleSampleAccumulator >":
	return _npstat.DSampleAccArrayND___add__(self, r)

	def __mul__(self, r: 'double const') -> "npstat::ArrayND< npstat::DoubleSampleAccumulator >":
	return _npstat.DSampleAccArrayND___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::ArrayND< npstat::DoubleSampleAccumulator >":
	return _npstat.DSampleAccArrayND___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::ArrayND< npstat::DoubleSampleAccumulator > &":
	return _npstat.DSampleAccArrayND___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::ArrayND< npstat::DoubleSampleAccumulator > &":
	return _npstat.DSampleAccArrayND___idiv__(self, r)

	def __iadd__(self, r: 'DSampleAccArrayND') -> "npstat::ArrayND< npstat::DoubleSampleAccumulator > &":
	return _npstat.DSampleAccArrayND___iadd__(self, r)

	def addmul(self, r: 'DSampleAccArrayND', c: 'double const') -> "npstat::ArrayND< npstat::DoubleSampleAccumulator > &":
	return _npstat.DSampleAccArrayND_addmul(self, r, c)

	def marginalize(self, r: 'npstat::ArrayND< npstat::ArrayND< npstat::DoubleSampleAccumulator,1U,10U >::proper_double > const &', indexMap: 'unsigned int const *', mapLen: 'unsigned int const') -> "npstat::ArrayND< npstat::DoubleSampleAccumulator >":
	return _npstat.DSampleAccArrayND_marginalize(self, r, indexMap, mapLen)

	def sum(self) -> "npstat::SampleAccumulator< double,long double >":
	return _npstat.DSampleAccArrayND_sum(self)

	def cdfValue(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::SampleAccumulator< double,long double >":
	return _npstat.DSampleAccArrayND_cdfValue(self, index, indexLen)

	def isShapeCompatible(self, r: 'DSampleAccArrayND') -> "bool":
	return _npstat.DSampleAccArrayND_isShapeCompatible(self, r)

	def exportSlice(self, slice: 'DSampleAccArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.DSampleAccArrayND_exportSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def exportMemSlice(self, slice: 'DoubleSampleAccumulator', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.DSampleAccArrayND_exportMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def importSlice(self, slice: 'DSampleAccArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.DSampleAccArrayND_importSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def importMemSlice(self, slice: 'DoubleSampleAccumulator', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.DSampleAccArrayND_importMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def multiplyBySlice(self, slice: 'npstat::ArrayND< npstat::ArrayND< npstat::DoubleSampleAccumulator,1U,10U >::proper_double > const &', fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayND< npstat::DoubleSampleAccumulator > &":
	return _npstat.DSampleAccArrayND_multiplyBySlice(self, slice, fixedIndices, nFixedIndices)

	def subrange(self, range: 'ArrayRange') -> "npstat::ArrayND< npstat::DoubleSampleAccumulator >":
	return _npstat.DSampleAccArrayND_subrange(self, range)

	def slice(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::ArrayND< npstat::DoubleSampleAccumulator >":
	return _npstat.DSampleAccArrayND_slice(self, index, indexLen)

	def rotate(self, shifts: 'unsigned int const *', lenShifts: 'unsigned int', rotated: 'DSampleAccArrayND') -> "void":
	return _npstat.DSampleAccArrayND_rotate(self, shifts, lenShifts, rotated)

	def exportSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', to: 'DSampleAccArrayND') -> "void":
	return _npstat.DSampleAccArrayND_exportSubrange(self, corner, lenCorner, to)

	def importSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', arg4: 'DSampleAccArrayND') -> "void":
	return _npstat.DSampleAccArrayND_importSubrange(self, corner, lenCorner, arg4)

	def multiMirror(self, out: 'DSampleAccArrayND') -> "void":
	return _npstat.DSampleAccArrayND_multiMirror(self, out)

	def __init__(self, *args):
	this = _npstat.new_DSampleAccArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	DSampleAccArrayND_swigregister = _npstat.DSampleAccArrayND_swigregister
	DSampleAccArrayND_swigregister(DSampleAccArrayND)

	def DSampleAccArrayND_classname() -> "char const *":
	return _npstat.DSampleAccArrayND_classname()
	DSampleAccArrayND_classname = _npstat.DSampleAccArrayND_classname

	def DSampleAccArrayND_version() -> "unsigned int":
	return _npstat.DSampleAccArrayND_version()
	DSampleAccArrayND_version = _npstat.DSampleAccArrayND_version

	def DSampleAccArrayND_restore(id: 'ClassId', arg3: 'istream', array: 'DSampleAccArrayND') -> "void":
	return _npstat.DSampleAccArrayND_restore(id, arg3, array)
	DSampleAccArrayND_restore = _npstat.DSampleAccArrayND_restore

	class DWSampleAccArrayND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DWSampleAccArrayND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DWSampleAccArrayND, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DWSampleAccArrayND
	__del__ = lambda self: None

	def uninitialize(self) -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator > &":
	return _npstat.DWSampleAccArrayND_uninitialize(self)

	def reshape(self, *args) -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator > &":
	return _npstat.DWSampleAccArrayND_reshape(self, *args)

	def valueAt(self, *args) -> "npstat::WeightedSampleAccumulator< double,long double > const &":
	return _npstat.DWSampleAccArrayND_valueAt(self, *args)

	def linearPtr(self, *args) -> "npstat::WeightedSampleAccumulator< double,long double > const &":
	return _npstat.DWSampleAccArrayND_linearPtr(self, *args)

	def convertLinearIndex(self, l: 'unsigned long', index: 'unsigned int *', indexLen: 'unsigned int') -> "void":
	return _npstat.DWSampleAccArrayND_convertLinearIndex(self, l, index, indexLen)

	def linearIndex(self, idx: 'unsigned int const *', idxLen: 'unsigned int') -> "unsigned long":
	return _npstat.DWSampleAccArrayND_linearIndex(self, idx, idxLen)

	def length(self) -> "unsigned long":
	return _npstat.DWSampleAccArrayND_length(self)

	def data(self) -> "npstat::WeightedSampleAccumulator< double,long double > const *":
	return _npstat.DWSampleAccArrayND_data(self)

	def isShapeKnown(self) -> "bool":
	return _npstat.DWSampleAccArrayND_isShapeKnown(self)

	def rank(self) -> "unsigned int":
	return _npstat.DWSampleAccArrayND_rank(self)

	def shape(self) -> "npstat::ArrayShape":
	return _npstat.DWSampleAccArrayND_shape(self)

	def shapeData(self) -> "unsigned int const *":
	return _npstat.DWSampleAccArrayND_shapeData(self)

	def fullRange(self) -> "npstat::ArrayRange":
	return _npstat.DWSampleAccArrayND_fullRange(self)

	def span(self, dim: 'unsigned int') -> "unsigned int":
	return _npstat.DWSampleAccArrayND_span(self, dim)

	def maximumSpan(self) -> "unsigned int":
	return _npstat.DWSampleAccArrayND_maximumSpan(self)

	def minimumSpan(self) -> "unsigned int":
	return _npstat.DWSampleAccArrayND_minimumSpan(self)

	def strides(self) -> "unsigned long const *":
	return _npstat.DWSampleAccArrayND_strides(self)

	def isZero(self) -> "bool":
	return _npstat.DWSampleAccArrayND_isZero(self)

	def __pos__(self) -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator >":
	return _npstat.DWSampleAccArrayND___pos__(self)

	def contract(self, pos1: 'unsigned int', pos2: 'unsigned int') -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator >":
	return _npstat.DWSampleAccArrayND_contract(self, pos1, pos2)

	def transpose(self, *args) -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator >":
	return _npstat.DWSampleAccArrayND_transpose(self, *args)

	def closestPtr(self, *args) -> "npstat::WeightedSampleAccumulator< double,long double > const &":
	return _npstat.DWSampleAccArrayND_closestPtr(self, *args)

	def constFill(self, c: 'DoubleWeightedSampleAccumulator') -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator > &":
	return _npstat.DWSampleAccArrayND_constFill(self, c)

	def clear(self) -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator > &":
	return _npstat.DWSampleAccArrayND_clear(self)

	def isCompatible(self, *args) -> "bool":
	return _npstat.DWSampleAccArrayND_isCompatible(self, *args)

	def sliceShape(self, fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayShape":
	return _npstat.DWSampleAccArrayND_sliceShape(self, fixedIndices, nFixedIndices)

	def ptr(self, *args) -> "npstat::WeightedSampleAccumulator< double,long double > const &":
	return _npstat.DWSampleAccArrayND_ptr(self, *args)

	def clPtr(self, *args) -> "npstat::WeightedSampleAccumulator< double,long double > const &":
	return _npstat.DWSampleAccArrayND_clPtr(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.DWSampleAccArrayND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DWSampleAccArrayND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DWSampleAccArrayND_classname)
	else:
	classname = _npstat.DWSampleAccArrayND_classname
	if _newclass:
	version = staticmethod(_npstat.DWSampleAccArrayND_version)
	else:
	version = _npstat.DWSampleAccArrayND_version
	if _newclass:
	restore = staticmethod(_npstat.DWSampleAccArrayND_restore)
	else:
	restore = _npstat.DWSampleAccArrayND_restore

	def setValue(self, index: 'unsigned int const *', indexLen: 'unsigned int', v: 'DoubleWeightedSampleAccumulator') -> "void":
	return _npstat.DWSampleAccArrayND_setValue(self, index, indexLen, v)

	def value(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::WeightedSampleAccumulator< double,long double >":
	return _npstat.DWSampleAccArrayND_value(self, index, indexLen)

	def setLinearValue(self, index: 'unsigned long', v: 'DoubleWeightedSampleAccumulator') -> "void":
	return _npstat.DWSampleAccArrayND_setLinearValue(self, index, v)

	def linearValue(self, index: 'unsigned long') -> "npstat::WeightedSampleAccumulator< double,long double >":
	return _npstat.DWSampleAccArrayND_linearValue(self, index)

	def setClosest(self, x: 'double const *', xDim: 'unsigned int', v: 'DoubleWeightedSampleAccumulator') -> "void":
	return _npstat.DWSampleAccArrayND_setClosest(self, x, xDim, v)

	def closest(self, x: 'double const *', xDim: 'unsigned int') -> "npstat::WeightedSampleAccumulator< double,long double > const":
	return _npstat.DWSampleAccArrayND_closest(self, x, xDim)

	def set(self, *args) -> "void":
	return _npstat.DWSampleAccArrayND_set(self, *args)

	def __call__(self, *args) -> "npstat::WeightedSampleAccumulator< double,long double >":
	return _npstat.DWSampleAccArrayND___call__(self, *args)

	def setCl(self, *args) -> "void":
	return _npstat.DWSampleAccArrayND_setCl(self, *args)

	def cl(self, *args) -> "npstat::WeightedSampleAccumulator< double,long double >":
	return _npstat.DWSampleAccArrayND_cl(self, *args)

	def setData(self, data: 'DoubleWeightedSampleAccumulator', dataLength: 'unsigned long') -> "void":
	return _npstat.DWSampleAccArrayND_setData(self, data, dataLength)

	def __eq__(self, r: 'DWSampleAccArrayND') -> "bool":
	return _npstat.DWSampleAccArrayND___eq__(self, r)

	def __ne__(self, r: 'DWSampleAccArrayND') -> "bool":
	return _npstat.DWSampleAccArrayND___ne__(self, r)

	def __add__(self, r: 'DWSampleAccArrayND') -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator >":
	return _npstat.DWSampleAccArrayND___add__(self, r)

	def __mul__(self, r: 'double const') -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator >":
	return _npstat.DWSampleAccArrayND___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator >":
	return _npstat.DWSampleAccArrayND___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator > &":
	return _npstat.DWSampleAccArrayND___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator > &":
	return _npstat.DWSampleAccArrayND___idiv__(self, r)

	def __iadd__(self, r: 'DWSampleAccArrayND') -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator > &":
	return _npstat.DWSampleAccArrayND___iadd__(self, r)

	def addmul(self, r: 'DWSampleAccArrayND', c: 'double const') -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator > &":
	return _npstat.DWSampleAccArrayND_addmul(self, r, c)

	def marginalize(self, r: 'npstat::ArrayND< npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator,1U,10U >::proper_double > const &', indexMap: 'unsigned int const *', mapLen: 'unsigned int const') -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator >":
	return _npstat.DWSampleAccArrayND_marginalize(self, r, indexMap, mapLen)

	def sum(self) -> "npstat::WeightedSampleAccumulator< double,long double >":
	return _npstat.DWSampleAccArrayND_sum(self)

	def cdfValue(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::WeightedSampleAccumulator< double,long double >":
	return _npstat.DWSampleAccArrayND_cdfValue(self, index, indexLen)

	def isShapeCompatible(self, r: 'DWSampleAccArrayND') -> "bool":
	return _npstat.DWSampleAccArrayND_isShapeCompatible(self, r)

	def exportSlice(self, slice: 'DWSampleAccArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.DWSampleAccArrayND_exportSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def exportMemSlice(self, slice: 'DoubleWeightedSampleAccumulator', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.DWSampleAccArrayND_exportMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def importSlice(self, slice: 'DWSampleAccArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.DWSampleAccArrayND_importSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def importMemSlice(self, slice: 'DoubleWeightedSampleAccumulator', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.DWSampleAccArrayND_importMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def multiplyBySlice(self, slice: 'npstat::ArrayND< npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator,1U,10U >::proper_double > const &', fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator > &":
	return _npstat.DWSampleAccArrayND_multiplyBySlice(self, slice, fixedIndices, nFixedIndices)

	def subrange(self, range: 'ArrayRange') -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator >":
	return _npstat.DWSampleAccArrayND_subrange(self, range)

	def slice(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator >":
	return _npstat.DWSampleAccArrayND_slice(self, index, indexLen)

	def rotate(self, shifts: 'unsigned int const *', lenShifts: 'unsigned int', rotated: 'DWSampleAccArrayND') -> "void":
	return _npstat.DWSampleAccArrayND_rotate(self, shifts, lenShifts, rotated)

	def exportSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', to: 'DWSampleAccArrayND') -> "void":
	return _npstat.DWSampleAccArrayND_exportSubrange(self, corner, lenCorner, to)

	def importSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', arg4: 'DWSampleAccArrayND') -> "void":
	return _npstat.DWSampleAccArrayND_importSubrange(self, corner, lenCorner, arg4)

	def multiMirror(self, out: 'DWSampleAccArrayND') -> "void":
	return _npstat.DWSampleAccArrayND_multiMirror(self, out)

	def __init__(self, *args):
	this = _npstat.new_DWSampleAccArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	DWSampleAccArrayND_swigregister = _npstat.DWSampleAccArrayND_swigregister
	DWSampleAccArrayND_swigregister(DWSampleAccArrayND)

	def DWSampleAccArrayND_classname() -> "char const *":
	return _npstat.DWSampleAccArrayND_classname()
	DWSampleAccArrayND_classname = _npstat.DWSampleAccArrayND_classname

	def DWSampleAccArrayND_version() -> "unsigned int":
	return _npstat.DWSampleAccArrayND_version()
	DWSampleAccArrayND_version = _npstat.DWSampleAccArrayND_version

	def DWSampleAccArrayND_restore(id: 'ClassId', arg3: 'istream', array: 'DWSampleAccArrayND') -> "void":
	return _npstat.DWSampleAccArrayND_restore(id, arg3, array)
	DWSampleAccArrayND_restore = _npstat.DWSampleAccArrayND_restore

	class BinSummaryArrayND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, BinSummaryArrayND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, BinSummaryArrayND, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_BinSummaryArrayND
	__del__ = lambda self: None

	def uninitialize(self) -> "npstat::ArrayND< npstat::BinSummary > &":
	return _npstat.BinSummaryArrayND_uninitialize(self)

	def reshape(self, *args) -> "npstat::ArrayND< npstat::BinSummary > &":
	return _npstat.BinSummaryArrayND_reshape(self, *args)

	def valueAt(self, *args) -> "npstat::BinSummary const &":
	return _npstat.BinSummaryArrayND_valueAt(self, *args)

	def linearPtr(self, *args) -> "npstat::BinSummary const &":
	return _npstat.BinSummaryArrayND_linearPtr(self, *args)

	def convertLinearIndex(self, l: 'unsigned long', index: 'unsigned int *', indexLen: 'unsigned int') -> "void":
	return _npstat.BinSummaryArrayND_convertLinearIndex(self, l, index, indexLen)

	def linearIndex(self, idx: 'unsigned int const *', idxLen: 'unsigned int') -> "unsigned long":
	return _npstat.BinSummaryArrayND_linearIndex(self, idx, idxLen)

	def length(self) -> "unsigned long":
	return _npstat.BinSummaryArrayND_length(self)

	def data(self) -> "npstat::BinSummary const *":
	return _npstat.BinSummaryArrayND_data(self)

	def isShapeKnown(self) -> "bool":
	return _npstat.BinSummaryArrayND_isShapeKnown(self)

	def rank(self) -> "unsigned int":
	return _npstat.BinSummaryArrayND_rank(self)

	def shape(self) -> "npstat::ArrayShape":
	return _npstat.BinSummaryArrayND_shape(self)

	def shapeData(self) -> "unsigned int const *":
	return _npstat.BinSummaryArrayND_shapeData(self)

	def fullRange(self) -> "npstat::ArrayRange":
	return _npstat.BinSummaryArrayND_fullRange(self)

	def span(self, dim: 'unsigned int') -> "unsigned int":
	return _npstat.BinSummaryArrayND_span(self, dim)

	def maximumSpan(self) -> "unsigned int":
	return _npstat.BinSummaryArrayND_maximumSpan(self)

	def minimumSpan(self) -> "unsigned int":
	return _npstat.BinSummaryArrayND_minimumSpan(self)

	def strides(self) -> "unsigned long const *":
	return _npstat.BinSummaryArrayND_strides(self)

	def isZero(self) -> "bool":
	return _npstat.BinSummaryArrayND_isZero(self)

	def __pos__(self) -> "npstat::ArrayND< npstat::BinSummary >":
	return _npstat.BinSummaryArrayND___pos__(self)

	def contract(self, pos1: 'unsigned int', pos2: 'unsigned int') -> "npstat::ArrayND< npstat::BinSummary >":
	return _npstat.BinSummaryArrayND_contract(self, pos1, pos2)

	def transpose(self, *args) -> "npstat::ArrayND< npstat::BinSummary >":
	return _npstat.BinSummaryArrayND_transpose(self, *args)

	def closestPtr(self, *args) -> "npstat::BinSummary const &":
	return _npstat.BinSummaryArrayND_closestPtr(self, *args)

	def constFill(self, c: 'BinSummary') -> "npstat::ArrayND< npstat::BinSummary > &":
	return _npstat.BinSummaryArrayND_constFill(self, c)

	def clear(self) -> "npstat::ArrayND< npstat::BinSummary > &":
	return _npstat.BinSummaryArrayND_clear(self)

	def isCompatible(self, *args) -> "bool":
	return _npstat.BinSummaryArrayND_isCompatible(self, *args)

	def sliceShape(self, fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayShape":
	return _npstat.BinSummaryArrayND_sliceShape(self, fixedIndices, nFixedIndices)

	def ptr(self, *args) -> "npstat::BinSummary const &":
	return _npstat.BinSummaryArrayND_ptr(self, *args)

	def clPtr(self, *args) -> "npstat::BinSummary const &":
	return _npstat.BinSummaryArrayND_clPtr(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.BinSummaryArrayND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.BinSummaryArrayND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.BinSummaryArrayND_classname)
	else:
	classname = _npstat.BinSummaryArrayND_classname
	if _newclass:
	version = staticmethod(_npstat.BinSummaryArrayND_version)
	else:
	version = _npstat.BinSummaryArrayND_version
	if _newclass:
	restore = staticmethod(_npstat.BinSummaryArrayND_restore)
	else:
	restore = _npstat.BinSummaryArrayND_restore

	def setValue(self, index: 'unsigned int const *', indexLen: 'unsigned int', v: 'BinSummary') -> "void":
	return _npstat.BinSummaryArrayND_setValue(self, index, indexLen, v)

	def value(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::BinSummary":
	return _npstat.BinSummaryArrayND_value(self, index, indexLen)

	def setLinearValue(self, index: 'unsigned long', v: 'BinSummary') -> "void":
	return _npstat.BinSummaryArrayND_setLinearValue(self, index, v)

	def linearValue(self, index: 'unsigned long') -> "npstat::BinSummary":
	return _npstat.BinSummaryArrayND_linearValue(self, index)

	def setClosest(self, x: 'double const *', xDim: 'unsigned int', v: 'BinSummary') -> "void":
	return _npstat.BinSummaryArrayND_setClosest(self, x, xDim, v)

	def closest(self, x: 'double const *', xDim: 'unsigned int') -> "npstat::BinSummary const":
	return _npstat.BinSummaryArrayND_closest(self, x, xDim)

	def set(self, *args) -> "void":
	return _npstat.BinSummaryArrayND_set(self, *args)

	def __call__(self, *args) -> "npstat::BinSummary":
	return _npstat.BinSummaryArrayND___call__(self, *args)

	def setCl(self, *args) -> "void":
	return _npstat.BinSummaryArrayND_setCl(self, *args)

	def cl(self, *args) -> "npstat::BinSummary":
	return _npstat.BinSummaryArrayND_cl(self, *args)

	def setData(self, data: 'BinSummary', dataLength: 'unsigned long') -> "void":
	return _npstat.BinSummaryArrayND_setData(self, data, dataLength)

	def __eq__(self, r: 'BinSummaryArrayND') -> "bool":
	return _npstat.BinSummaryArrayND___eq__(self, r)

	def __ne__(self, r: 'BinSummaryArrayND') -> "bool":
	return _npstat.BinSummaryArrayND___ne__(self, r)

	def __add__(self, r: 'BinSummaryArrayND') -> "npstat::ArrayND< npstat::BinSummary >":
	return _npstat.BinSummaryArrayND___add__(self, r)

	def __mul__(self, r: 'double const') -> "npstat::ArrayND< npstat::BinSummary >":
	return _npstat.BinSummaryArrayND___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::ArrayND< npstat::BinSummary >":
	return _npstat.BinSummaryArrayND___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::ArrayND< npstat::BinSummary > &":
	return _npstat.BinSummaryArrayND___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::ArrayND< npstat::BinSummary > &":
	return _npstat.BinSummaryArrayND___idiv__(self, r)

	def __iadd__(self, r: 'BinSummaryArrayND') -> "npstat::ArrayND< npstat::BinSummary > &":
	return _npstat.BinSummaryArrayND___iadd__(self, r)

	def addmul(self, r: 'BinSummaryArrayND', c: 'double const') -> "npstat::ArrayND< npstat::BinSummary > &":
	return _npstat.BinSummaryArrayND_addmul(self, r, c)

	def marginalize(self, r: 'npstat::ArrayND< npstat::ArrayND< npstat::BinSummary,1U,10U >::proper_double > const &', indexMap: 'unsigned int const *', mapLen: 'unsigned int const') -> "npstat::ArrayND< npstat::BinSummary >":
	return _npstat.BinSummaryArrayND_marginalize(self, r, indexMap, mapLen)

	def sum(self) -> "npstat::BinSummary":
	return _npstat.BinSummaryArrayND_sum(self)

	def cdfValue(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::BinSummary":
	return _npstat.BinSummaryArrayND_cdfValue(self, index, indexLen)

	def isShapeCompatible(self, r: 'BinSummaryArrayND') -> "bool":
	return _npstat.BinSummaryArrayND_isShapeCompatible(self, r)

	def exportSlice(self, slice: 'BinSummaryArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.BinSummaryArrayND_exportSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def exportMemSlice(self, slice: 'BinSummary', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.BinSummaryArrayND_exportMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def importSlice(self, slice: 'BinSummaryArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.BinSummaryArrayND_importSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def importMemSlice(self, slice: 'BinSummary', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.BinSummaryArrayND_importMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def multiplyBySlice(self, slice: 'npstat::ArrayND< npstat::ArrayND< npstat::BinSummary,1U,10U >::proper_double > const &', fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayND< npstat::BinSummary > &":
	return _npstat.BinSummaryArrayND_multiplyBySlice(self, slice, fixedIndices, nFixedIndices)

	def subrange(self, range: 'ArrayRange') -> "npstat::ArrayND< npstat::BinSummary >":
	return _npstat.BinSummaryArrayND_subrange(self, range)

	def slice(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::ArrayND< npstat::BinSummary >":
	return _npstat.BinSummaryArrayND_slice(self, index, indexLen)

	def rotate(self, shifts: 'unsigned int const *', lenShifts: 'unsigned int', rotated: 'BinSummaryArrayND') -> "void":
	return _npstat.BinSummaryArrayND_rotate(self, shifts, lenShifts, rotated)

	def exportSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', to: 'BinSummaryArrayND') -> "void":
	return _npstat.BinSummaryArrayND_exportSubrange(self, corner, lenCorner, to)

	def importSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', arg4: 'BinSummaryArrayND') -> "void":
	return _npstat.BinSummaryArrayND_importSubrange(self, corner, lenCorner, arg4)

	def multiMirror(self, out: 'BinSummaryArrayND') -> "void":
	return _npstat.BinSummaryArrayND_multiMirror(self, out)

	def __init__(self, *args):
	this = _npstat.new_BinSummaryArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	BinSummaryArrayND_swigregister = _npstat.BinSummaryArrayND_swigregister
	BinSummaryArrayND_swigregister(BinSummaryArrayND)

	def BinSummaryArrayND_classname() -> "char const *":
	return _npstat.BinSummaryArrayND_classname()
	BinSummaryArrayND_classname = _npstat.BinSummaryArrayND_classname

	def BinSummaryArrayND_version() -> "unsigned int":
	return _npstat.BinSummaryArrayND_version()
	BinSummaryArrayND_version = _npstat.BinSummaryArrayND_version

	def BinSummaryArrayND_restore(id: 'ClassId', arg3: 'istream', array: 'BinSummaryArrayND') -> "void":
	return _npstat.BinSummaryArrayND_restore(id, arg3, array)
	BinSummaryArrayND_restore = _npstat.BinSummaryArrayND_restore

	def ArrayND(*args):
	val = _npstat.new_ArrayND(*args)
	return val

	class ArchiveRecord_StatAccArrayND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_StatAccArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_StatAccArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'StatAccArrayND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_StatAccArrayND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_StatAccArrayND
	__del__ = lambda self: None
	ArchiveRecord_StatAccArrayND_swigregister = _npstat.ArchiveRecord_StatAccArrayND_swigregister
	ArchiveRecord_StatAccArrayND_swigregister(ArchiveRecord_StatAccArrayND)

	class Ref_StatAccArrayND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_StatAccArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_StatAccArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_StatAccArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'StatAccArrayND') -> "void":
	return _npstat.Ref_StatAccArrayND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::ArrayND< npstat::StatAccumulator,1U,10U > *":
	return _npstat.Ref_StatAccArrayND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::ArrayND< npstat::StatAccumulator,1U,10U >":
	return _npstat.Ref_StatAccArrayND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_StatAccArrayND
	__del__ = lambda self: None
	Ref_StatAccArrayND_swigregister = _npstat.Ref_StatAccArrayND_swigregister
	Ref_StatAccArrayND_swigregister(Ref_StatAccArrayND)

	class ArchiveRecord_WStatAccArrayND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_WStatAccArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_WStatAccArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'WStatAccArrayND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_WStatAccArrayND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_WStatAccArrayND
	__del__ = lambda self: None
	ArchiveRecord_WStatAccArrayND_swigregister = _npstat.ArchiveRecord_WStatAccArrayND_swigregister
	ArchiveRecord_WStatAccArrayND_swigregister(ArchiveRecord_WStatAccArrayND)

	class Ref_WStatAccArrayND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_WStatAccArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_WStatAccArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_WStatAccArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'WStatAccArrayND') -> "void":
	return _npstat.Ref_WStatAccArrayND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::ArrayND< npstat::WeightedStatAccumulator,1U,10U > *":
	return _npstat.Ref_WStatAccArrayND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::ArrayND< npstat::WeightedStatAccumulator,1U,10U >":
	return _npstat.Ref_WStatAccArrayND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_WStatAccArrayND
	__del__ = lambda self: None
	Ref_WStatAccArrayND_swigregister = _npstat.Ref_WStatAccArrayND_swigregister
	Ref_WStatAccArrayND_swigregister(Ref_WStatAccArrayND)

	class ArchiveRecord_FSampleAccArrayND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_FSampleAccArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_FSampleAccArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'FSampleAccArrayND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_FSampleAccArrayND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_FSampleAccArrayND
	__del__ = lambda self: None
	ArchiveRecord_FSampleAccArrayND_swigregister = _npstat.ArchiveRecord_FSampleAccArrayND_swigregister
	ArchiveRecord_FSampleAccArrayND_swigregister(ArchiveRecord_FSampleAccArrayND)

	class Ref_FSampleAccArrayND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_FSampleAccArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_FSampleAccArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_FSampleAccArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'FSampleAccArrayND') -> "void":
	return _npstat.Ref_FSampleAccArrayND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::ArrayND< npstat::FloatSampleAccumulator,1U,10U > *":
	return _npstat.Ref_FSampleAccArrayND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::ArrayND< npstat::FloatSampleAccumulator,1U,10U >":
	return _npstat.Ref_FSampleAccArrayND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_FSampleAccArrayND
	__del__ = lambda self: None
	Ref_FSampleAccArrayND_swigregister = _npstat.Ref_FSampleAccArrayND_swigregister
	Ref_FSampleAccArrayND_swigregister(Ref_FSampleAccArrayND)

	class ArchiveRecord_DSampleAccArrayND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DSampleAccArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DSampleAccArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DSampleAccArrayND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DSampleAccArrayND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DSampleAccArrayND
	__del__ = lambda self: None
	ArchiveRecord_DSampleAccArrayND_swigregister = _npstat.ArchiveRecord_DSampleAccArrayND_swigregister
	ArchiveRecord_DSampleAccArrayND_swigregister(ArchiveRecord_DSampleAccArrayND)

	class Ref_DSampleAccArrayND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DSampleAccArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DSampleAccArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DSampleAccArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DSampleAccArrayND') -> "void":
	return _npstat.Ref_DSampleAccArrayND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::ArrayND< npstat::DoubleSampleAccumulator,1U,10U > *":
	return _npstat.Ref_DSampleAccArrayND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::ArrayND< npstat::DoubleSampleAccumulator,1U,10U >":
	return _npstat.Ref_DSampleAccArrayND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DSampleAccArrayND
	__del__ = lambda self: None
	Ref_DSampleAccArrayND_swigregister = _npstat.Ref_DSampleAccArrayND_swigregister
	Ref_DSampleAccArrayND_swigregister(Ref_DSampleAccArrayND)

	class ArchiveRecord_DWSampleAccArrayND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DWSampleAccArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DWSampleAccArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DWSampleAccArrayND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DWSampleAccArrayND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DWSampleAccArrayND
	__del__ = lambda self: None
	ArchiveRecord_DWSampleAccArrayND_swigregister = _npstat.ArchiveRecord_DWSampleAccArrayND_swigregister
	ArchiveRecord_DWSampleAccArrayND_swigregister(ArchiveRecord_DWSampleAccArrayND)

	class Ref_DWSampleAccArrayND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DWSampleAccArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DWSampleAccArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DWSampleAccArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DWSampleAccArrayND') -> "void":
	return _npstat.Ref_DWSampleAccArrayND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator,1U,10U > *":
	return _npstat.Ref_DWSampleAccArrayND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator,1U,10U >":
	return _npstat.Ref_DWSampleAccArrayND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DWSampleAccArrayND
	__del__ = lambda self: None
	Ref_DWSampleAccArrayND_swigregister = _npstat.Ref_DWSampleAccArrayND_swigregister
	Ref_DWSampleAccArrayND_swigregister(Ref_DWSampleAccArrayND)

	class ArchiveRecord_BinSummaryArrayND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_BinSummaryArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_BinSummaryArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'BinSummaryArrayND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_BinSummaryArrayND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_BinSummaryArrayND
	__del__ = lambda self: None
	ArchiveRecord_BinSummaryArrayND_swigregister = _npstat.ArchiveRecord_BinSummaryArrayND_swigregister
	ArchiveRecord_BinSummaryArrayND_swigregister(ArchiveRecord_BinSummaryArrayND)

	class Ref_BinSummaryArrayND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_BinSummaryArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_BinSummaryArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_BinSummaryArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'BinSummaryArrayND') -> "void":
	return _npstat.Ref_BinSummaryArrayND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::ArrayND< npstat::BinSummary,1U,10U > *":
	return _npstat.Ref_BinSummaryArrayND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::ArrayND< npstat::BinSummary,1U,10U >":
	return _npstat.Ref_BinSummaryArrayND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_BinSummaryArrayND
	__del__ = lambda self: None
	Ref_BinSummaryArrayND_swigregister = _npstat.Ref_BinSummaryArrayND_swigregister
	Ref_BinSummaryArrayND_swigregister(Ref_BinSummaryArrayND)

	class UCharArrayND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharArrayND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharArrayND, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_UCharArrayND
	__del__ = lambda self: None

	def uninitialize(self) -> "npstat::ArrayND< unsigned char > &":
	return _npstat.UCharArrayND_uninitialize(self)

	def reshape(self, *args) -> "npstat::ArrayND< unsigned char > &":
	return _npstat.UCharArrayND_reshape(self, *args)

	def valueAt(self, *args) -> "unsigned char const &":
	return _npstat.UCharArrayND_valueAt(self, *args)

	def linearPtr(self, *args) -> "unsigned char const &":
	return _npstat.UCharArrayND_linearPtr(self, *args)

	def convertLinearIndex(self, l: 'unsigned long', index: 'unsigned int *', indexLen: 'unsigned int') -> "void":
	return _npstat.UCharArrayND_convertLinearIndex(self, l, index, indexLen)

	def linearIndex(self, idx: 'unsigned int const *', idxLen: 'unsigned int') -> "unsigned long":
	return _npstat.UCharArrayND_linearIndex(self, idx, idxLen)

	def length(self) -> "unsigned long":
	return _npstat.UCharArrayND_length(self)

	def data(self) -> "unsigned char const *":
	return _npstat.UCharArrayND_data(self)

	def isShapeKnown(self) -> "bool":
	return _npstat.UCharArrayND_isShapeKnown(self)

	def rank(self) -> "unsigned int":
	return _npstat.UCharArrayND_rank(self)

	def shape(self) -> "npstat::ArrayShape":
	return _npstat.UCharArrayND_shape(self)

	def shapeData(self) -> "unsigned int const *":
	return _npstat.UCharArrayND_shapeData(self)

	def fullRange(self) -> "npstat::ArrayRange":
	return _npstat.UCharArrayND_fullRange(self)

	def span(self, dim: 'unsigned int') -> "unsigned int":
	return _npstat.UCharArrayND_span(self, dim)

	def maximumSpan(self) -> "unsigned int":
	return _npstat.UCharArrayND_maximumSpan(self)

	def minimumSpan(self) -> "unsigned int":
	return _npstat.UCharArrayND_minimumSpan(self)

	def strides(self) -> "unsigned long const *":
	return _npstat.UCharArrayND_strides(self)

	def isZero(self) -> "bool":
	return _npstat.UCharArrayND_isZero(self)

	def isDensity(self) -> "bool":
	return _npstat.UCharArrayND_isDensity(self)

	def __pos__(self) -> "npstat::ArrayND< unsigned char >":
	return _npstat.UCharArrayND___pos__(self)

	def __neg__(self) -> "npstat::ArrayND< unsigned char >":
	return _npstat.UCharArrayND___neg__(self)

	def contract(self, pos1: 'unsigned int', pos2: 'unsigned int') -> "npstat::ArrayND< unsigned char >":
	return _npstat.UCharArrayND_contract(self, pos1, pos2)

	def transpose(self, *args) -> "npstat::ArrayND< unsigned char >":
	return _npstat.UCharArrayND_transpose(self, *args)

	def min(self, *args) -> "unsigned char":
	return _npstat.UCharArrayND_min(self, *args)

	def max(self, *args) -> "unsigned char":
	return _npstat.UCharArrayND_max(self, *args)

	def closestPtr(self, *args) -> "unsigned char const &":
	return _npstat.UCharArrayND_closestPtr(self, *args)

	def interpolate1(self, x: 'double const *', xDim: 'unsigned int') -> "unsigned char":
	return _npstat.UCharArrayND_interpolate1(self, x, xDim)

	def interpolate3(self, x: 'double const *', xDim: 'unsigned int') -> "unsigned char":
	return _npstat.UCharArrayND_interpolate3(self, x, xDim)

	def constFill(self, c: 'unsigned char') -> "npstat::ArrayND< unsigned char > &":
	return _npstat.UCharArrayND_constFill(self, c)

	def clear(self) -> "npstat::ArrayND< unsigned char > &":
	return _npstat.UCharArrayND_clear(self)

	def linearFill(self, coeff: 'double const *', coeffLen: 'unsigned int', c: 'double') -> "npstat::ArrayND< unsigned char > &":
	return _npstat.UCharArrayND_linearFill(self, coeff, coeffLen, c)

	def makeUnit(self) -> "npstat::ArrayND< unsigned char > &":
	return _npstat.UCharArrayND_makeUnit(self)

	def makeNonNegative(self) -> "npstat::ArrayND< unsigned char > &":
	return _npstat.UCharArrayND_makeNonNegative(self)

	def makeCopulaSteps(self, tolerance: 'double', maxIterations: 'unsigned int') -> "unsigned int":
	return _npstat.UCharArrayND_makeCopulaSteps(self, tolerance, maxIterations)

	def isCompatible(self, *args) -> "bool":
	return _npstat.UCharArrayND_isCompatible(self, *args)

	def sliceShape(self, fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayShape":
	return _npstat.UCharArrayND_sliceShape(self, fixedIndices, nFixedIndices)

	def ptr(self, *args) -> "unsigned char const &":
	return _npstat.UCharArrayND_ptr(self, *args)

	def clPtr(self, *args) -> "unsigned char const &":
	return _npstat.UCharArrayND_clPtr(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.UCharArrayND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.UCharArrayND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.UCharArrayND_classname)
	else:
	classname = _npstat.UCharArrayND_classname
	if _newclass:
	version = staticmethod(_npstat.UCharArrayND_version)
	else:
	version = _npstat.UCharArrayND_version
	if _newclass:
	restore = staticmethod(_npstat.UCharArrayND_restore)
	else:
	restore = _npstat.UCharArrayND_restore

	def setValue(self, index: 'unsigned int const *', indexLen: 'unsigned int', v: 'unsigned char') -> "void":
	return _npstat.UCharArrayND_setValue(self, index, indexLen, v)

	def value(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "unsigned char":
	return _npstat.UCharArrayND_value(self, index, indexLen)

	def setLinearValue(self, index: 'unsigned long', v: 'unsigned char') -> "void":
	return _npstat.UCharArrayND_setLinearValue(self, index, v)

	def linearValue(self, index: 'unsigned long') -> "unsigned char":
	return _npstat.UCharArrayND_linearValue(self, index)

	def setClosest(self, x: 'double const *', xDim: 'unsigned int', v: 'unsigned char') -> "void":
	return _npstat.UCharArrayND_setClosest(self, x, xDim, v)

	def closest(self, x: 'double const *', xDim: 'unsigned int') -> "unsigned char const":
	return _npstat.UCharArrayND_closest(self, x, xDim)

	def set(self, *args) -> "void":
	return _npstat.UCharArrayND_set(self, *args)

	def __call__(self, *args) -> "unsigned char":
	return _npstat.UCharArrayND___call__(self, *args)

	def setCl(self, *args) -> "void":
	return _npstat.UCharArrayND_setCl(self, *args)

	def cl(self, *args) -> "unsigned char":
	return _npstat.UCharArrayND_cl(self, *args)

	def setData(self, data: 'unsigned char const *', dataLength: 'unsigned long') -> "void":
	return _npstat.UCharArrayND_setData(self, data, dataLength)

	def maxAbsDifference(self, r: 'UCharArrayND') -> "double":
	return _npstat.UCharArrayND_maxAbsDifference(self, r)

	def __eq__(self, r: 'UCharArrayND') -> "bool":
	return _npstat.UCharArrayND___eq__(self, r)

	def __ne__(self, r: 'UCharArrayND') -> "bool":
	return _npstat.UCharArrayND___ne__(self, r)

	def __add__(self, r: 'UCharArrayND') -> "npstat::ArrayND< unsigned char >":
	return _npstat.UCharArrayND___add__(self, r)

	def __sub__(self, r: 'UCharArrayND') -> "npstat::ArrayND< unsigned char >":
	return _npstat.UCharArrayND___sub__(self, r)

	def __mul__(self, r: 'double const') -> "npstat::ArrayND< unsigned char >":
	return _npstat.UCharArrayND___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::ArrayND< unsigned char >":
	return _npstat.UCharArrayND___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::ArrayND< unsigned char > &":
	return _npstat.UCharArrayND___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::ArrayND< unsigned char > &":
	return _npstat.UCharArrayND___idiv__(self, r)

	def __iadd__(self, r: 'UCharArrayND') -> "npstat::ArrayND< unsigned char > &":
	return _npstat.UCharArrayND___iadd__(self, r)

	def __isub__(self, r: 'UCharArrayND') -> "npstat::ArrayND< unsigned char > &":
	return _npstat.UCharArrayND___isub__(self, r)

	def addmul(self, r: 'UCharArrayND', c: 'double const') -> "npstat::ArrayND< unsigned char > &":
	return _npstat.UCharArrayND_addmul(self, r, c)

	def inPlaceMul(self, r: 'UCharArrayND') -> "npstat::ArrayND< unsigned char > &":
	return _npstat.UCharArrayND_inPlaceMul(self, r)

	def outer(self, r: 'UCharArrayND') -> "npstat::ArrayND< unsigned char >":
	return _npstat.UCharArrayND_outer(self, r)

	def dot(self, r: 'UCharArrayND') -> "npstat::ArrayND< unsigned char >":
	return _npstat.UCharArrayND_dot(self, r)

	def marginalize(self, r: 'npstat::ArrayND< npstat::ArrayND< unsigned char,1U,10U >::proper_double > const &', indexMap: 'unsigned int const *', mapLen: 'unsigned int const') -> "npstat::ArrayND< unsigned char >":
	return _npstat.UCharArrayND_marginalize(self, r, indexMap, mapLen)

	def sum(self) -> "unsigned char":
	return _npstat.UCharArrayND_sum(self)

	def sumsq(self) -> "double":
	return _npstat.UCharArrayND_sumsq(self)

	def derivative(self, scale: 'double'=1.0) -> "npstat::ArrayND< unsigned char >":
	return _npstat.UCharArrayND_derivative(self, scale)

	def cdfArray(self, scale: 'double'=1.0) -> "npstat::ArrayND< unsigned char >":
	return _npstat.UCharArrayND_cdfArray(self, scale)

	def cdfValue(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "unsigned char":
	return _npstat.UCharArrayND_cdfValue(self, index, indexLen)

	def convertToLastDimCdf(self, sumSlice: 'UCharArrayND', b: 'bool') -> "void":
	return _npstat.UCharArrayND_convertToLastDimCdf(self, sumSlice, b)

	def isClose(self, r: 'UCharArrayND', eps: 'double') -> "bool":
	return _npstat.UCharArrayND_isClose(self, r, eps)

	def isShapeCompatible(self, r: 'UCharArrayND') -> "bool":
	return _npstat.UCharArrayND_isShapeCompatible(self, r)

	def exportSlice(self, slice: 'UCharArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.UCharArrayND_exportSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def exportMemSlice(self, slice: 'unsigned char ', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const *', nFixedInd: 'unsigned int') -> "void":
	return _npstat.UCharArrayND_exportMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def importSlice(self, slice: 'UCharArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.UCharArrayND_importSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def importMemSlice(self, slice: 'unsigned char const ', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const *', nFixedInd: 'unsigned int') -> "void":
	return _npstat.UCharArrayND_importMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def multiplyBySlice(self, slice: 'npstat::ArrayND< npstat::ArrayND< unsigned char,1U,10U >::proper_double > const &', fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayND< unsigned char > &":
	return _npstat.UCharArrayND_multiplyBySlice(self, slice, fixedIndices, nFixedIndices)

	def subrange(self, range: 'ArrayRange') -> "npstat::ArrayND< unsigned char >":
	return _npstat.UCharArrayND_subrange(self, range)

	def slice(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::ArrayND< unsigned char >":
	return _npstat.UCharArrayND_slice(self, index, indexLen)

	def rotate(self, shifts: 'unsigned int const *', lenShifts: 'unsigned int', rotated: 'UCharArrayND') -> "void":
	return _npstat.UCharArrayND_rotate(self, shifts, lenShifts, rotated)

	def exportSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', to: 'UCharArrayND') -> "void":
	return _npstat.UCharArrayND_exportSubrange(self, corner, lenCorner, to)

	def importSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', arg4: 'UCharArrayND') -> "void":
	return _npstat.UCharArrayND_importSubrange(self, corner, lenCorner, arg4)

	def multiMirror(self, out: 'UCharArrayND') -> "void":
	return _npstat.UCharArrayND_multiMirror(self, out)

	def __init__(self, *args):
	this = _npstat.new_UCharArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	UCharArrayND_swigregister = _npstat.UCharArrayND_swigregister
	UCharArrayND_swigregister(UCharArrayND)

	def UCharArrayND_classname() -> "char const *":
	return _npstat.UCharArrayND_classname()
	UCharArrayND_classname = _npstat.UCharArrayND_classname

	def UCharArrayND_version() -> "unsigned int":
	return _npstat.UCharArrayND_version()
	UCharArrayND_version = _npstat.UCharArrayND_version

	def UCharArrayND_restore(id: 'ClassId', arg3: 'istream', array: 'UCharArrayND') -> "void":
	return _npstat.UCharArrayND_restore(id, arg3, array)
	UCharArrayND_restore = _npstat.UCharArrayND_restore

	class ArchiveRecord_UCharArrayND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_UCharArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_UCharArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'UCharArrayND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_UCharArrayND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_UCharArrayND
	__del__ = lambda self: None
	ArchiveRecord_UCharArrayND_swigregister = _npstat.ArchiveRecord_UCharArrayND_swigregister
	ArchiveRecord_UCharArrayND_swigregister(ArchiveRecord_UCharArrayND)

	class Ref_UCharArrayND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_UCharArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_UCharArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_UCharArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'UCharArrayND') -> "void":
	return _npstat.Ref_UCharArrayND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::ArrayND< unsigned char,1U,10U > *":
	return _npstat.Ref_UCharArrayND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::ArrayND< unsigned char,1U,10U >":
	return _npstat.Ref_UCharArrayND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_UCharArrayND
	__del__ = lambda self: None
	Ref_UCharArrayND_swigregister = _npstat.Ref_UCharArrayND_swigregister
	Ref_UCharArrayND_swigregister(Ref_UCharArrayND)

	class IntArrayND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntArrayND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntArrayND, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_IntArrayND
	__del__ = lambda self: None

	def uninitialize(self) -> "npstat::ArrayND< int > &":
	return _npstat.IntArrayND_uninitialize(self)

	def reshape(self, *args) -> "npstat::ArrayND< int > &":
	return _npstat.IntArrayND_reshape(self, *args)

	def valueAt(self, *args) -> "int const &":
	return _npstat.IntArrayND_valueAt(self, *args)

	def linearPtr(self, *args) -> "int const &":
	return _npstat.IntArrayND_linearPtr(self, *args)

	def convertLinearIndex(self, l: 'unsigned long', index: 'unsigned int *', indexLen: 'unsigned int') -> "void":
	return _npstat.IntArrayND_convertLinearIndex(self, l, index, indexLen)

	def linearIndex(self, idx: 'unsigned int const *', idxLen: 'unsigned int') -> "unsigned long":
	return _npstat.IntArrayND_linearIndex(self, idx, idxLen)

	def length(self) -> "unsigned long":
	return _npstat.IntArrayND_length(self)

	def data(self) -> "int const *":
	return _npstat.IntArrayND_data(self)

	def isShapeKnown(self) -> "bool":
	return _npstat.IntArrayND_isShapeKnown(self)

	def rank(self) -> "unsigned int":
	return _npstat.IntArrayND_rank(self)

	def shape(self) -> "npstat::ArrayShape":
	return _npstat.IntArrayND_shape(self)

	def shapeData(self) -> "unsigned int const *":
	return _npstat.IntArrayND_shapeData(self)

	def fullRange(self) -> "npstat::ArrayRange":
	return _npstat.IntArrayND_fullRange(self)

	def span(self, dim: 'unsigned int') -> "unsigned int":
	return _npstat.IntArrayND_span(self, dim)

	def maximumSpan(self) -> "unsigned int":
	return _npstat.IntArrayND_maximumSpan(self)

	def minimumSpan(self) -> "unsigned int":
	return _npstat.IntArrayND_minimumSpan(self)

	def strides(self) -> "unsigned long const *":
	return _npstat.IntArrayND_strides(self)

	def isZero(self) -> "bool":
	return _npstat.IntArrayND_isZero(self)

	def isDensity(self) -> "bool":
	return _npstat.IntArrayND_isDensity(self)

	def __pos__(self) -> "npstat::ArrayND< int >":
	return _npstat.IntArrayND___pos__(self)

	def __neg__(self) -> "npstat::ArrayND< int >":
	return _npstat.IntArrayND___neg__(self)

	def contract(self, pos1: 'unsigned int', pos2: 'unsigned int') -> "npstat::ArrayND< int >":
	return _npstat.IntArrayND_contract(self, pos1, pos2)

	def transpose(self, *args) -> "npstat::ArrayND< int >":
	return _npstat.IntArrayND_transpose(self, *args)

	def min(self, *args) -> "int":
	return _npstat.IntArrayND_min(self, *args)

	def max(self, *args) -> "int":
	return _npstat.IntArrayND_max(self, *args)

	def closestPtr(self, *args) -> "int const &":
	return _npstat.IntArrayND_closestPtr(self, *args)

	def interpolate1(self, x: 'double const *', xDim: 'unsigned int') -> "int":
	return _npstat.IntArrayND_interpolate1(self, x, xDim)

	def interpolate3(self, x: 'double const *', xDim: 'unsigned int') -> "int":
	return _npstat.IntArrayND_interpolate3(self, x, xDim)

	def constFill(self, c: 'int') -> "npstat::ArrayND< int > &":
	return _npstat.IntArrayND_constFill(self, c)

	def clear(self) -> "npstat::ArrayND< int > &":
	return _npstat.IntArrayND_clear(self)

	def linearFill(self, coeff: 'double const *', coeffLen: 'unsigned int', c: 'double') -> "npstat::ArrayND< int > &":
	return _npstat.IntArrayND_linearFill(self, coeff, coeffLen, c)

	def makeUnit(self) -> "npstat::ArrayND< int > &":
	return _npstat.IntArrayND_makeUnit(self)

	def makeNonNegative(self) -> "npstat::ArrayND< int > &":
	return _npstat.IntArrayND_makeNonNegative(self)

	def makeCopulaSteps(self, tolerance: 'double', maxIterations: 'unsigned int') -> "unsigned int":
	return _npstat.IntArrayND_makeCopulaSteps(self, tolerance, maxIterations)

	def isCompatible(self, *args) -> "bool":
	return _npstat.IntArrayND_isCompatible(self, *args)

	def sliceShape(self, fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayShape":
	return _npstat.IntArrayND_sliceShape(self, fixedIndices, nFixedIndices)

	def ptr(self, *args) -> "int const &":
	return _npstat.IntArrayND_ptr(self, *args)

	def clPtr(self, *args) -> "int const &":
	return _npstat.IntArrayND_clPtr(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.IntArrayND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.IntArrayND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.IntArrayND_classname)
	else:
	classname = _npstat.IntArrayND_classname
	if _newclass:
	version = staticmethod(_npstat.IntArrayND_version)
	else:
	version = _npstat.IntArrayND_version
	if _newclass:
	restore = staticmethod(_npstat.IntArrayND_restore)
	else:
	restore = _npstat.IntArrayND_restore

	def setValue(self, index: 'unsigned int const *', indexLen: 'unsigned int', v: 'int') -> "void":
	return _npstat.IntArrayND_setValue(self, index, indexLen, v)

	def value(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "int":
	return _npstat.IntArrayND_value(self, index, indexLen)

	def setLinearValue(self, index: 'unsigned long', v: 'int') -> "void":
	return _npstat.IntArrayND_setLinearValue(self, index, v)

	def linearValue(self, index: 'unsigned long') -> "int":
	return _npstat.IntArrayND_linearValue(self, index)

	def setClosest(self, x: 'double const *', xDim: 'unsigned int', v: 'int') -> "void":
	return _npstat.IntArrayND_setClosest(self, x, xDim, v)

	def closest(self, x: 'double const *', xDim: 'unsigned int') -> "int const":
	return _npstat.IntArrayND_closest(self, x, xDim)

	def set(self, *args) -> "void":
	return _npstat.IntArrayND_set(self, *args)

	def __call__(self, *args) -> "int":
	return _npstat.IntArrayND___call__(self, *args)

	def setCl(self, *args) -> "void":
	return _npstat.IntArrayND_setCl(self, *args)

	def cl(self, *args) -> "int":
	return _npstat.IntArrayND_cl(self, *args)

	def setData(self, data: 'int const *', dataLength: 'unsigned long') -> "void":
	return _npstat.IntArrayND_setData(self, data, dataLength)

	def maxAbsDifference(self, r: 'IntArrayND') -> "double":
	return _npstat.IntArrayND_maxAbsDifference(self, r)

	def __eq__(self, r: 'IntArrayND') -> "bool":
	return _npstat.IntArrayND___eq__(self, r)

	def __ne__(self, r: 'IntArrayND') -> "bool":
	return _npstat.IntArrayND___ne__(self, r)

	def __add__(self, r: 'IntArrayND') -> "npstat::ArrayND< int >":
	return _npstat.IntArrayND___add__(self, r)

	def __sub__(self, r: 'IntArrayND') -> "npstat::ArrayND< int >":
	return _npstat.IntArrayND___sub__(self, r)

	def __mul__(self, r: 'double const') -> "npstat::ArrayND< int >":
	return _npstat.IntArrayND___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::ArrayND< int >":
	return _npstat.IntArrayND___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::ArrayND< int > &":
	return _npstat.IntArrayND___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::ArrayND< int > &":
	return _npstat.IntArrayND___idiv__(self, r)

	def __iadd__(self, r: 'IntArrayND') -> "npstat::ArrayND< int > &":
	return _npstat.IntArrayND___iadd__(self, r)

	def __isub__(self, r: 'IntArrayND') -> "npstat::ArrayND< int > &":
	return _npstat.IntArrayND___isub__(self, r)

	def addmul(self, r: 'IntArrayND', c: 'double const') -> "npstat::ArrayND< int > &":
	return _npstat.IntArrayND_addmul(self, r, c)

	def inPlaceMul(self, r: 'IntArrayND') -> "npstat::ArrayND< int > &":
	return _npstat.IntArrayND_inPlaceMul(self, r)

	def outer(self, r: 'IntArrayND') -> "npstat::ArrayND< int >":
	return _npstat.IntArrayND_outer(self, r)

	def dot(self, r: 'IntArrayND') -> "npstat::ArrayND< int >":
	return _npstat.IntArrayND_dot(self, r)

	def marginalize(self, r: 'npstat::ArrayND< npstat::ArrayND< int,1U,10U >::proper_double > const &', indexMap: 'unsigned int const *', mapLen: 'unsigned int const') -> "npstat::ArrayND< int >":
	return _npstat.IntArrayND_marginalize(self, r, indexMap, mapLen)

	def sum(self) -> "int":
	return _npstat.IntArrayND_sum(self)

	def sumsq(self) -> "double":
	return _npstat.IntArrayND_sumsq(self)

	def derivative(self, scale: 'double'=1.0) -> "npstat::ArrayND< int >":
	return _npstat.IntArrayND_derivative(self, scale)

	def cdfArray(self, scale: 'double'=1.0) -> "npstat::ArrayND< int >":
	return _npstat.IntArrayND_cdfArray(self, scale)

	def cdfValue(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "int":
	return _npstat.IntArrayND_cdfValue(self, index, indexLen)

	def convertToLastDimCdf(self, sumSlice: 'IntArrayND', b: 'bool') -> "void":
	return _npstat.IntArrayND_convertToLastDimCdf(self, sumSlice, b)

	def isClose(self, r: 'IntArrayND', eps: 'double') -> "bool":
	return _npstat.IntArrayND_isClose(self, r, eps)

	def isShapeCompatible(self, r: 'IntArrayND') -> "bool":
	return _npstat.IntArrayND_isShapeCompatible(self, r)

	def exportSlice(self, slice: 'IntArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.IntArrayND_exportSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def exportMemSlice(self, slice: 'int ', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const *', nFixedInd: 'unsigned int') -> "void":
	return _npstat.IntArrayND_exportMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def importSlice(self, slice: 'IntArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.IntArrayND_importSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def importMemSlice(self, slice: 'int const ', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const *', nFixedInd: 'unsigned int') -> "void":
	return _npstat.IntArrayND_importMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def multiplyBySlice(self, slice: 'npstat::ArrayND< npstat::ArrayND< int,1U,10U >::proper_double > const &', fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayND< int > &":
	return _npstat.IntArrayND_multiplyBySlice(self, slice, fixedIndices, nFixedIndices)

	def subrange(self, range: 'ArrayRange') -> "npstat::ArrayND< int >":
	return _npstat.IntArrayND_subrange(self, range)

	def slice(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::ArrayND< int >":
	return _npstat.IntArrayND_slice(self, index, indexLen)

	def rotate(self, shifts: 'unsigned int const *', lenShifts: 'unsigned int', rotated: 'IntArrayND') -> "void":
	return _npstat.IntArrayND_rotate(self, shifts, lenShifts, rotated)

	def exportSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', to: 'IntArrayND') -> "void":
	return _npstat.IntArrayND_exportSubrange(self, corner, lenCorner, to)

	def importSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', arg4: 'IntArrayND') -> "void":
	return _npstat.IntArrayND_importSubrange(self, corner, lenCorner, arg4)

	def multiMirror(self, out: 'IntArrayND') -> "void":
	return _npstat.IntArrayND_multiMirror(self, out)

	def __init__(self, *args):
	this = _npstat.new_IntArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	IntArrayND_swigregister = _npstat.IntArrayND_swigregister
	IntArrayND_swigregister(IntArrayND)

	def IntArrayND_classname() -> "char const *":
	return _npstat.IntArrayND_classname()
	IntArrayND_classname = _npstat.IntArrayND_classname

	def IntArrayND_version() -> "unsigned int":
	return _npstat.IntArrayND_version()
	IntArrayND_version = _npstat.IntArrayND_version

	def IntArrayND_restore(id: 'ClassId', arg3: 'istream', array: 'IntArrayND') -> "void":
	return _npstat.IntArrayND_restore(id, arg3, array)
	IntArrayND_restore = _npstat.IntArrayND_restore

	class ArchiveRecord_IntArrayND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_IntArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_IntArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'IntArrayND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_IntArrayND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_IntArrayND
	__del__ = lambda self: None
	ArchiveRecord_IntArrayND_swigregister = _npstat.ArchiveRecord_IntArrayND_swigregister
	ArchiveRecord_IntArrayND_swigregister(ArchiveRecord_IntArrayND)

	class Ref_IntArrayND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_IntArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_IntArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_IntArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'IntArrayND') -> "void":
	return _npstat.Ref_IntArrayND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::ArrayND< int,1U,10U > *":
	return _npstat.Ref_IntArrayND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::ArrayND< int,1U,10U >":
	return _npstat.Ref_IntArrayND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_IntArrayND
	__del__ = lambda self: None
	Ref_IntArrayND_swigregister = _npstat.Ref_IntArrayND_swigregister
	Ref_IntArrayND_swigregister(Ref_IntArrayND)

	class LLongArrayND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongArrayND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongArrayND, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LLongArrayND
	__del__ = lambda self: None

	def uninitialize(self) -> "npstat::ArrayND< long long > &":
	return _npstat.LLongArrayND_uninitialize(self)

	def reshape(self, *args) -> "npstat::ArrayND< long long > &":
	return _npstat.LLongArrayND_reshape(self, *args)

	def valueAt(self, *args) -> "long long const &":
	return _npstat.LLongArrayND_valueAt(self, *args)

	def linearPtr(self, *args) -> "long long const &":
	return _npstat.LLongArrayND_linearPtr(self, *args)

	def convertLinearIndex(self, l: 'unsigned long', index: 'unsigned int *', indexLen: 'unsigned int') -> "void":
	return _npstat.LLongArrayND_convertLinearIndex(self, l, index, indexLen)

	def linearIndex(self, idx: 'unsigned int const *', idxLen: 'unsigned int') -> "unsigned long":
	return _npstat.LLongArrayND_linearIndex(self, idx, idxLen)

	def length(self) -> "unsigned long":
	return _npstat.LLongArrayND_length(self)

	def data(self) -> "long long const *":
	return _npstat.LLongArrayND_data(self)

	def isShapeKnown(self) -> "bool":
	return _npstat.LLongArrayND_isShapeKnown(self)

	def rank(self) -> "unsigned int":
	return _npstat.LLongArrayND_rank(self)

	def shape(self) -> "npstat::ArrayShape":
	return _npstat.LLongArrayND_shape(self)

	def shapeData(self) -> "unsigned int const *":
	return _npstat.LLongArrayND_shapeData(self)

	def fullRange(self) -> "npstat::ArrayRange":
	return _npstat.LLongArrayND_fullRange(self)

	def span(self, dim: 'unsigned int') -> "unsigned int":
	return _npstat.LLongArrayND_span(self, dim)

	def maximumSpan(self) -> "unsigned int":
	return _npstat.LLongArrayND_maximumSpan(self)

	def minimumSpan(self) -> "unsigned int":
	return _npstat.LLongArrayND_minimumSpan(self)

	def strides(self) -> "unsigned long const *":
	return _npstat.LLongArrayND_strides(self)

	def isZero(self) -> "bool":
	return _npstat.LLongArrayND_isZero(self)

	def isDensity(self) -> "bool":
	return _npstat.LLongArrayND_isDensity(self)

	def __pos__(self) -> "npstat::ArrayND< long long >":
	return _npstat.LLongArrayND___pos__(self)

	def __neg__(self) -> "npstat::ArrayND< long long >":
	return _npstat.LLongArrayND___neg__(self)

	def contract(self, pos1: 'unsigned int', pos2: 'unsigned int') -> "npstat::ArrayND< long long >":
	return _npstat.LLongArrayND_contract(self, pos1, pos2)

	def transpose(self, *args) -> "npstat::ArrayND< long long >":
	return _npstat.LLongArrayND_transpose(self, *args)

	def min(self, *args) -> "long long":
	return _npstat.LLongArrayND_min(self, *args)

	def max(self, *args) -> "long long":
	return _npstat.LLongArrayND_max(self, *args)

	def closestPtr(self, *args) -> "long long const &":
	return _npstat.LLongArrayND_closestPtr(self, *args)

	def interpolate1(self, x: 'double const *', xDim: 'unsigned int') -> "long long":
	return _npstat.LLongArrayND_interpolate1(self, x, xDim)

	def interpolate3(self, x: 'double const *', xDim: 'unsigned int') -> "long long":
	return _npstat.LLongArrayND_interpolate3(self, x, xDim)

	def constFill(self, c: 'long long') -> "npstat::ArrayND< long long > &":
	return _npstat.LLongArrayND_constFill(self, c)

	def clear(self) -> "npstat::ArrayND< long long > &":
	return _npstat.LLongArrayND_clear(self)

	def linearFill(self, coeff: 'double const *', coeffLen: 'unsigned int', c: 'double') -> "npstat::ArrayND< long long > &":
	return _npstat.LLongArrayND_linearFill(self, coeff, coeffLen, c)

	def makeUnit(self) -> "npstat::ArrayND< long long > &":
	return _npstat.LLongArrayND_makeUnit(self)

	def makeNonNegative(self) -> "npstat::ArrayND< long long > &":
	return _npstat.LLongArrayND_makeNonNegative(self)

	def makeCopulaSteps(self, tolerance: 'double', maxIterations: 'unsigned int') -> "unsigned int":
	return _npstat.LLongArrayND_makeCopulaSteps(self, tolerance, maxIterations)

	def isCompatible(self, *args) -> "bool":
	return _npstat.LLongArrayND_isCompatible(self, *args)

	def sliceShape(self, fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayShape":
	return _npstat.LLongArrayND_sliceShape(self, fixedIndices, nFixedIndices)

	def ptr(self, *args) -> "long long const &":
	return _npstat.LLongArrayND_ptr(self, *args)

	def clPtr(self, *args) -> "long long const &":
	return _npstat.LLongArrayND_clPtr(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.LLongArrayND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.LLongArrayND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.LLongArrayND_classname)
	else:
	classname = _npstat.LLongArrayND_classname
	if _newclass:
	version = staticmethod(_npstat.LLongArrayND_version)
	else:
	version = _npstat.LLongArrayND_version
	if _newclass:
	restore = staticmethod(_npstat.LLongArrayND_restore)
	else:
	restore = _npstat.LLongArrayND_restore

	def setValue(self, index: 'unsigned int const *', indexLen: 'unsigned int', v: 'long long') -> "void":
	return _npstat.LLongArrayND_setValue(self, index, indexLen, v)

	def value(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "long long":
	return _npstat.LLongArrayND_value(self, index, indexLen)

	def setLinearValue(self, index: 'unsigned long', v: 'long long') -> "void":
	return _npstat.LLongArrayND_setLinearValue(self, index, v)

	def linearValue(self, index: 'unsigned long') -> "long long":
	return _npstat.LLongArrayND_linearValue(self, index)

	def setClosest(self, x: 'double const *', xDim: 'unsigned int', v: 'long long') -> "void":
	return _npstat.LLongArrayND_setClosest(self, x, xDim, v)

	def closest(self, x: 'double const *', xDim: 'unsigned int') -> "long long const":
	return _npstat.LLongArrayND_closest(self, x, xDim)

	def set(self, *args) -> "void":
	return _npstat.LLongArrayND_set(self, *args)

	def __call__(self, *args) -> "long long":
	return _npstat.LLongArrayND___call__(self, *args)

	def setCl(self, *args) -> "void":
	return _npstat.LLongArrayND_setCl(self, *args)

	def cl(self, *args) -> "long long":
	return _npstat.LLongArrayND_cl(self, *args)

	def setData(self, data: 'long long const *', dataLength: 'unsigned long') -> "void":
	return _npstat.LLongArrayND_setData(self, data, dataLength)

	def maxAbsDifference(self, r: 'LLongArrayND') -> "double":
	return _npstat.LLongArrayND_maxAbsDifference(self, r)

	def __eq__(self, r: 'LLongArrayND') -> "bool":
	return _npstat.LLongArrayND___eq__(self, r)

	def __ne__(self, r: 'LLongArrayND') -> "bool":
	return _npstat.LLongArrayND___ne__(self, r)

	def __add__(self, r: 'LLongArrayND') -> "npstat::ArrayND< long long >":
	return _npstat.LLongArrayND___add__(self, r)

	def __sub__(self, r: 'LLongArrayND') -> "npstat::ArrayND< long long >":
	return _npstat.LLongArrayND___sub__(self, r)

	def __mul__(self, r: 'double const') -> "npstat::ArrayND< long long >":
	return _npstat.LLongArrayND___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::ArrayND< long long >":
	return _npstat.LLongArrayND___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::ArrayND< long long > &":
	return _npstat.LLongArrayND___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::ArrayND< long long > &":
	return _npstat.LLongArrayND___idiv__(self, r)

	def __iadd__(self, r: 'LLongArrayND') -> "npstat::ArrayND< long long > &":
	return _npstat.LLongArrayND___iadd__(self, r)

	def __isub__(self, r: 'LLongArrayND') -> "npstat::ArrayND< long long > &":
	return _npstat.LLongArrayND___isub__(self, r)

	def addmul(self, r: 'LLongArrayND', c: 'double const') -> "npstat::ArrayND< long long > &":
	return _npstat.LLongArrayND_addmul(self, r, c)

	def inPlaceMul(self, r: 'LLongArrayND') -> "npstat::ArrayND< long long > &":
	return _npstat.LLongArrayND_inPlaceMul(self, r)

	def outer(self, r: 'LLongArrayND') -> "npstat::ArrayND< long long >":
	return _npstat.LLongArrayND_outer(self, r)

	def dot(self, r: 'LLongArrayND') -> "npstat::ArrayND< long long >":
	return _npstat.LLongArrayND_dot(self, r)

	def marginalize(self, r: 'npstat::ArrayND< npstat::ArrayND< long long,1U,10U >::proper_double > const &', indexMap: 'unsigned int const *', mapLen: 'unsigned int const') -> "npstat::ArrayND< long long >":
	return _npstat.LLongArrayND_marginalize(self, r, indexMap, mapLen)

	def sum(self) -> "long long":
	return _npstat.LLongArrayND_sum(self)

	def sumsq(self) -> "double":
	return _npstat.LLongArrayND_sumsq(self)

	def derivative(self, scale: 'double'=1.0) -> "npstat::ArrayND< long long >":
	return _npstat.LLongArrayND_derivative(self, scale)

	def cdfArray(self, scale: 'double'=1.0) -> "npstat::ArrayND< long long >":
	return _npstat.LLongArrayND_cdfArray(self, scale)

	def cdfValue(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "long long":
	return _npstat.LLongArrayND_cdfValue(self, index, indexLen)

	def convertToLastDimCdf(self, sumSlice: 'LLongArrayND', b: 'bool') -> "void":
	return _npstat.LLongArrayND_convertToLastDimCdf(self, sumSlice, b)

	def isClose(self, r: 'LLongArrayND', eps: 'double') -> "bool":
	return _npstat.LLongArrayND_isClose(self, r, eps)

	def isShapeCompatible(self, r: 'LLongArrayND') -> "bool":
	return _npstat.LLongArrayND_isShapeCompatible(self, r)

	def exportSlice(self, slice: 'LLongArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.LLongArrayND_exportSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def exportMemSlice(self, slice: 'long long ', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const *', nFixedInd: 'unsigned int') -> "void":
	return _npstat.LLongArrayND_exportMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def importSlice(self, slice: 'LLongArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.LLongArrayND_importSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def importMemSlice(self, slice: 'long long const ', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const *', nFixedInd: 'unsigned int') -> "void":
	return _npstat.LLongArrayND_importMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def multiplyBySlice(self, slice: 'npstat::ArrayND< npstat::ArrayND< long long,1U,10U >::proper_double > const &', fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayND< long long > &":
	return _npstat.LLongArrayND_multiplyBySlice(self, slice, fixedIndices, nFixedIndices)

	def subrange(self, range: 'ArrayRange') -> "npstat::ArrayND< long long >":
	return _npstat.LLongArrayND_subrange(self, range)

	def slice(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::ArrayND< long long >":
	return _npstat.LLongArrayND_slice(self, index, indexLen)

	def rotate(self, shifts: 'unsigned int const *', lenShifts: 'unsigned int', rotated: 'LLongArrayND') -> "void":
	return _npstat.LLongArrayND_rotate(self, shifts, lenShifts, rotated)

	def exportSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', to: 'LLongArrayND') -> "void":
	return _npstat.LLongArrayND_exportSubrange(self, corner, lenCorner, to)

	def importSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', arg4: 'LLongArrayND') -> "void":
	return _npstat.LLongArrayND_importSubrange(self, corner, lenCorner, arg4)

	def multiMirror(self, out: 'LLongArrayND') -> "void":
	return _npstat.LLongArrayND_multiMirror(self, out)

	def __init__(self, *args):
	this = _npstat.new_LLongArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	LLongArrayND_swigregister = _npstat.LLongArrayND_swigregister
	LLongArrayND_swigregister(LLongArrayND)

	def LLongArrayND_classname() -> "char const *":
	return _npstat.LLongArrayND_classname()
	LLongArrayND_classname = _npstat.LLongArrayND_classname

	def LLongArrayND_version() -> "unsigned int":
	return _npstat.LLongArrayND_version()
	LLongArrayND_version = _npstat.LLongArrayND_version

	def LLongArrayND_restore(id: 'ClassId', arg3: 'istream', array: 'LLongArrayND') -> "void":
	return _npstat.LLongArrayND_restore(id, arg3, array)
	LLongArrayND_restore = _npstat.LLongArrayND_restore

	class ArchiveRecord_LLongArrayND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_LLongArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_LLongArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'LLongArrayND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_LLongArrayND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_LLongArrayND
	__del__ = lambda self: None
	ArchiveRecord_LLongArrayND_swigregister = _npstat.ArchiveRecord_LLongArrayND_swigregister
	ArchiveRecord_LLongArrayND_swigregister(ArchiveRecord_LLongArrayND)

	class Ref_LLongArrayND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_LLongArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_LLongArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_LLongArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'LLongArrayND') -> "void":
	return _npstat.Ref_LLongArrayND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::ArrayND< long long,1U,10U > *":
	return _npstat.Ref_LLongArrayND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::ArrayND< long long,1U,10U >":
	return _npstat.Ref_LLongArrayND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_LLongArrayND
	__del__ = lambda self: None
	Ref_LLongArrayND_swigregister = _npstat.Ref_LLongArrayND_swigregister
	Ref_LLongArrayND_swigregister(Ref_LLongArrayND)

	class FloatArrayND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatArrayND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatArrayND, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatArrayND
	__del__ = lambda self: None

	def uninitialize(self) -> "npstat::ArrayND< float > &":
	return _npstat.FloatArrayND_uninitialize(self)

	def reshape(self, *args) -> "npstat::ArrayND< float > &":
	return _npstat.FloatArrayND_reshape(self, *args)

	def valueAt(self, *args) -> "float const &":
	return _npstat.FloatArrayND_valueAt(self, *args)

	def linearPtr(self, *args) -> "float const &":
	return _npstat.FloatArrayND_linearPtr(self, *args)

	def convertLinearIndex(self, l: 'unsigned long', index: 'unsigned int *', indexLen: 'unsigned int') -> "void":
	return _npstat.FloatArrayND_convertLinearIndex(self, l, index, indexLen)

	def linearIndex(self, idx: 'unsigned int const *', idxLen: 'unsigned int') -> "unsigned long":
	return _npstat.FloatArrayND_linearIndex(self, idx, idxLen)

	def length(self) -> "unsigned long":
	return _npstat.FloatArrayND_length(self)

	def data(self) -> "float const *":
	return _npstat.FloatArrayND_data(self)

	def isShapeKnown(self) -> "bool":
	return _npstat.FloatArrayND_isShapeKnown(self)

	def rank(self) -> "unsigned int":
	return _npstat.FloatArrayND_rank(self)

	def shape(self) -> "npstat::ArrayShape":
	return _npstat.FloatArrayND_shape(self)

	def shapeData(self) -> "unsigned int const *":
	return _npstat.FloatArrayND_shapeData(self)

	def fullRange(self) -> "npstat::ArrayRange":
	return _npstat.FloatArrayND_fullRange(self)

	def span(self, dim: 'unsigned int') -> "unsigned int":
	return _npstat.FloatArrayND_span(self, dim)

	def maximumSpan(self) -> "unsigned int":
	return _npstat.FloatArrayND_maximumSpan(self)

	def minimumSpan(self) -> "unsigned int":
	return _npstat.FloatArrayND_minimumSpan(self)

	def strides(self) -> "unsigned long const *":
	return _npstat.FloatArrayND_strides(self)

	def isZero(self) -> "bool":
	return _npstat.FloatArrayND_isZero(self)

	def isDensity(self) -> "bool":
	return _npstat.FloatArrayND_isDensity(self)

	def __pos__(self) -> "npstat::ArrayND< float >":
	return _npstat.FloatArrayND___pos__(self)

	def __neg__(self) -> "npstat::ArrayND< float >":
	return _npstat.FloatArrayND___neg__(self)

	def contract(self, pos1: 'unsigned int', pos2: 'unsigned int') -> "npstat::ArrayND< float >":
	return _npstat.FloatArrayND_contract(self, pos1, pos2)

	def transpose(self, *args) -> "npstat::ArrayND< float >":
	return _npstat.FloatArrayND_transpose(self, *args)

	def min(self, *args) -> "float":
	return _npstat.FloatArrayND_min(self, *args)

	def max(self, *args) -> "float":
	return _npstat.FloatArrayND_max(self, *args)

	def closestPtr(self, *args) -> "float const &":
	return _npstat.FloatArrayND_closestPtr(self, *args)

	def interpolate1(self, x: 'double const *', xDim: 'unsigned int') -> "float":
	return _npstat.FloatArrayND_interpolate1(self, x, xDim)

	def interpolate3(self, x: 'double const *', xDim: 'unsigned int') -> "float":
	return _npstat.FloatArrayND_interpolate3(self, x, xDim)

	def constFill(self, c: 'float') -> "npstat::ArrayND< float > &":
	return _npstat.FloatArrayND_constFill(self, c)

	def clear(self) -> "npstat::ArrayND< float > &":
	return _npstat.FloatArrayND_clear(self)

	def linearFill(self, coeff: 'double const *', coeffLen: 'unsigned int', c: 'double') -> "npstat::ArrayND< float > &":
	return _npstat.FloatArrayND_linearFill(self, coeff, coeffLen, c)

	def makeUnit(self) -> "npstat::ArrayND< float > &":
	return _npstat.FloatArrayND_makeUnit(self)

	def makeNonNegative(self) -> "npstat::ArrayND< float > &":
	return _npstat.FloatArrayND_makeNonNegative(self)

	def makeCopulaSteps(self, tolerance: 'double', maxIterations: 'unsigned int') -> "unsigned int":
	return _npstat.FloatArrayND_makeCopulaSteps(self, tolerance, maxIterations)

	def isCompatible(self, *args) -> "bool":
	return _npstat.FloatArrayND_isCompatible(self, *args)

	def sliceShape(self, fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayShape":
	return _npstat.FloatArrayND_sliceShape(self, fixedIndices, nFixedIndices)

	def ptr(self, *args) -> "float const &":
	return _npstat.FloatArrayND_ptr(self, *args)

	def clPtr(self, *args) -> "float const &":
	return _npstat.FloatArrayND_clPtr(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatArrayND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatArrayND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatArrayND_classname)
	else:
	classname = _npstat.FloatArrayND_classname
	if _newclass:
	version = staticmethod(_npstat.FloatArrayND_version)
	else:
	version = _npstat.FloatArrayND_version
	if _newclass:
	restore = staticmethod(_npstat.FloatArrayND_restore)
	else:
	restore = _npstat.FloatArrayND_restore

	def setValue(self, index: 'unsigned int const *', indexLen: 'unsigned int', v: 'float') -> "void":
	return _npstat.FloatArrayND_setValue(self, index, indexLen, v)

	def value(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "float":
	return _npstat.FloatArrayND_value(self, index, indexLen)

	def setLinearValue(self, index: 'unsigned long', v: 'float') -> "void":
	return _npstat.FloatArrayND_setLinearValue(self, index, v)

	def linearValue(self, index: 'unsigned long') -> "float":
	return _npstat.FloatArrayND_linearValue(self, index)

	def setClosest(self, x: 'double const *', xDim: 'unsigned int', v: 'float') -> "void":
	return _npstat.FloatArrayND_setClosest(self, x, xDim, v)

	def closest(self, x: 'double const *', xDim: 'unsigned int') -> "float const":
	return _npstat.FloatArrayND_closest(self, x, xDim)

	def set(self, *args) -> "void":
	return _npstat.FloatArrayND_set(self, *args)

	def __call__(self, *args) -> "float":
	return _npstat.FloatArrayND___call__(self, *args)

	def setCl(self, *args) -> "void":
	return _npstat.FloatArrayND_setCl(self, *args)

	def cl(self, *args) -> "float":
	return _npstat.FloatArrayND_cl(self, *args)

	def setData(self, data: 'float const *', dataLength: 'unsigned long') -> "void":
	return _npstat.FloatArrayND_setData(self, data, dataLength)

	def maxAbsDifference(self, r: 'FloatArrayND') -> "double":
	return _npstat.FloatArrayND_maxAbsDifference(self, r)

	def __eq__(self, r: 'FloatArrayND') -> "bool":
	return _npstat.FloatArrayND___eq__(self, r)

	def __ne__(self, r: 'FloatArrayND') -> "bool":
	return _npstat.FloatArrayND___ne__(self, r)

	def __add__(self, r: 'FloatArrayND') -> "npstat::ArrayND< float >":
	return _npstat.FloatArrayND___add__(self, r)

	def __sub__(self, r: 'FloatArrayND') -> "npstat::ArrayND< float >":
	return _npstat.FloatArrayND___sub__(self, r)

	def __mul__(self, r: 'double const') -> "npstat::ArrayND< float >":
	return _npstat.FloatArrayND___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::ArrayND< float >":
	return _npstat.FloatArrayND___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::ArrayND< float > &":
	return _npstat.FloatArrayND___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::ArrayND< float > &":
	return _npstat.FloatArrayND___idiv__(self, r)

	def __iadd__(self, r: 'FloatArrayND') -> "npstat::ArrayND< float > &":
	return _npstat.FloatArrayND___iadd__(self, r)

	def __isub__(self, r: 'FloatArrayND') -> "npstat::ArrayND< float > &":
	return _npstat.FloatArrayND___isub__(self, r)

	def addmul(self, r: 'FloatArrayND', c: 'double const') -> "npstat::ArrayND< float > &":
	return _npstat.FloatArrayND_addmul(self, r, c)

	def inPlaceMul(self, r: 'FloatArrayND') -> "npstat::ArrayND< float > &":
	return _npstat.FloatArrayND_inPlaceMul(self, r)

	def outer(self, r: 'FloatArrayND') -> "npstat::ArrayND< float >":
	return _npstat.FloatArrayND_outer(self, r)

	def dot(self, r: 'FloatArrayND') -> "npstat::ArrayND< float >":
	return _npstat.FloatArrayND_dot(self, r)

	def marginalize(self, r: 'npstat::ArrayND< npstat::ArrayND< float,1U,10U >::proper_double > const &', indexMap: 'unsigned int const *', mapLen: 'unsigned int const') -> "npstat::ArrayND< float >":
	return _npstat.FloatArrayND_marginalize(self, r, indexMap, mapLen)

	def sum(self) -> "float":
	return _npstat.FloatArrayND_sum(self)

	def sumsq(self) -> "double":
	return _npstat.FloatArrayND_sumsq(self)

	def derivative(self, scale: 'double'=1.0) -> "npstat::ArrayND< float >":
	return _npstat.FloatArrayND_derivative(self, scale)

	def cdfArray(self, scale: 'double'=1.0) -> "npstat::ArrayND< float >":
	return _npstat.FloatArrayND_cdfArray(self, scale)

	def cdfValue(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "float":
	return _npstat.FloatArrayND_cdfValue(self, index, indexLen)

	def convertToLastDimCdf(self, sumSlice: 'FloatArrayND', b: 'bool') -> "void":
	return _npstat.FloatArrayND_convertToLastDimCdf(self, sumSlice, b)

	def isClose(self, r: 'FloatArrayND', eps: 'double') -> "bool":
	return _npstat.FloatArrayND_isClose(self, r, eps)

	def isShapeCompatible(self, r: 'FloatArrayND') -> "bool":
	return _npstat.FloatArrayND_isShapeCompatible(self, r)

	def exportSlice(self, slice: 'FloatArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.FloatArrayND_exportSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def exportMemSlice(self, slice: 'float ', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const *', nFixedInd: 'unsigned int') -> "void":
	return _npstat.FloatArrayND_exportMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def importSlice(self, slice: 'FloatArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.FloatArrayND_importSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def importMemSlice(self, slice: 'float const ', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const *', nFixedInd: 'unsigned int') -> "void":
	return _npstat.FloatArrayND_importMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def multiplyBySlice(self, slice: 'npstat::ArrayND< npstat::ArrayND< float,1U,10U >::proper_double > const &', fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayND< float > &":
	return _npstat.FloatArrayND_multiplyBySlice(self, slice, fixedIndices, nFixedIndices)

	def subrange(self, range: 'ArrayRange') -> "npstat::ArrayND< float >":
	return _npstat.FloatArrayND_subrange(self, range)

	def slice(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::ArrayND< float >":
	return _npstat.FloatArrayND_slice(self, index, indexLen)

	def rotate(self, shifts: 'unsigned int const *', lenShifts: 'unsigned int', rotated: 'FloatArrayND') -> "void":
	return _npstat.FloatArrayND_rotate(self, shifts, lenShifts, rotated)

	def exportSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', to: 'FloatArrayND') -> "void":
	return _npstat.FloatArrayND_exportSubrange(self, corner, lenCorner, to)

	def importSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', arg4: 'FloatArrayND') -> "void":
	return _npstat.FloatArrayND_importSubrange(self, corner, lenCorner, arg4)

	def multiMirror(self, out: 'FloatArrayND') -> "void":
	return _npstat.FloatArrayND_multiMirror(self, out)

	def __init__(self, *args):
	this = _npstat.new_FloatArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	FloatArrayND_swigregister = _npstat.FloatArrayND_swigregister
	FloatArrayND_swigregister(FloatArrayND)

	def FloatArrayND_classname() -> "char const *":
	return _npstat.FloatArrayND_classname()
	FloatArrayND_classname = _npstat.FloatArrayND_classname

	def FloatArrayND_version() -> "unsigned int":
	return _npstat.FloatArrayND_version()
	FloatArrayND_version = _npstat.FloatArrayND_version

	def FloatArrayND_restore(id: 'ClassId', arg3: 'istream', array: 'FloatArrayND') -> "void":
	return _npstat.FloatArrayND_restore(id, arg3, array)
	FloatArrayND_restore = _npstat.FloatArrayND_restore

	class ArchiveRecord_FloatArrayND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_FloatArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_FloatArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'FloatArrayND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_FloatArrayND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_FloatArrayND
	__del__ = lambda self: None
	ArchiveRecord_FloatArrayND_swigregister = _npstat.ArchiveRecord_FloatArrayND_swigregister
	ArchiveRecord_FloatArrayND_swigregister(ArchiveRecord_FloatArrayND)

	class Ref_FloatArrayND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_FloatArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_FloatArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_FloatArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'FloatArrayND') -> "void":
	return _npstat.Ref_FloatArrayND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::ArrayND< float,1U,10U > *":
	return _npstat.Ref_FloatArrayND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::ArrayND< float,1U,10U >":
	return _npstat.Ref_FloatArrayND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_FloatArrayND
	__del__ = lambda self: None
	Ref_FloatArrayND_swigregister = _npstat.Ref_FloatArrayND_swigregister
	Ref_FloatArrayND_swigregister(Ref_FloatArrayND)

	class DoubleArrayND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleArrayND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleArrayND, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleArrayND
	__del__ = lambda self: None

	def uninitialize(self) -> "npstat::ArrayND< double > &":
	return _npstat.DoubleArrayND_uninitialize(self)

	def reshape(self, *args) -> "npstat::ArrayND< double > &":
	return _npstat.DoubleArrayND_reshape(self, *args)

	def valueAt(self, *args) -> "double const &":
	return _npstat.DoubleArrayND_valueAt(self, *args)

	def linearPtr(self, *args) -> "double const &":
	return _npstat.DoubleArrayND_linearPtr(self, *args)

	def convertLinearIndex(self, l: 'unsigned long', index: 'unsigned int *', indexLen: 'unsigned int') -> "void":
	return _npstat.DoubleArrayND_convertLinearIndex(self, l, index, indexLen)

	def linearIndex(self, idx: 'unsigned int const *', idxLen: 'unsigned int') -> "unsigned long":
	return _npstat.DoubleArrayND_linearIndex(self, idx, idxLen)

	def length(self) -> "unsigned long":
	return _npstat.DoubleArrayND_length(self)

	def data(self) -> "double const *":
	return _npstat.DoubleArrayND_data(self)

	def isShapeKnown(self) -> "bool":
	return _npstat.DoubleArrayND_isShapeKnown(self)

	def rank(self) -> "unsigned int":
	return _npstat.DoubleArrayND_rank(self)

	def shape(self) -> "npstat::ArrayShape":
	return _npstat.DoubleArrayND_shape(self)

	def shapeData(self) -> "unsigned int const *":
	return _npstat.DoubleArrayND_shapeData(self)

	def fullRange(self) -> "npstat::ArrayRange":
	return _npstat.DoubleArrayND_fullRange(self)

	def span(self, dim: 'unsigned int') -> "unsigned int":
	return _npstat.DoubleArrayND_span(self, dim)

	def maximumSpan(self) -> "unsigned int":
	return _npstat.DoubleArrayND_maximumSpan(self)

	def minimumSpan(self) -> "unsigned int":
	return _npstat.DoubleArrayND_minimumSpan(self)

	def strides(self) -> "unsigned long const *":
	return _npstat.DoubleArrayND_strides(self)

	def isZero(self) -> "bool":
	return _npstat.DoubleArrayND_isZero(self)

	def isDensity(self) -> "bool":
	return _npstat.DoubleArrayND_isDensity(self)

	def __pos__(self) -> "npstat::ArrayND< double >":
	return _npstat.DoubleArrayND___pos__(self)

	def __neg__(self) -> "npstat::ArrayND< double >":
	return _npstat.DoubleArrayND___neg__(self)

	def contract(self, pos1: 'unsigned int', pos2: 'unsigned int') -> "npstat::ArrayND< double >":
	return _npstat.DoubleArrayND_contract(self, pos1, pos2)

	def transpose(self, *args) -> "npstat::ArrayND< double >":
	return _npstat.DoubleArrayND_transpose(self, *args)

	def min(self, *args) -> "double":
	return _npstat.DoubleArrayND_min(self, *args)

	def max(self, *args) -> "double":
	return _npstat.DoubleArrayND_max(self, *args)

	def closestPtr(self, *args) -> "double const &":
	return _npstat.DoubleArrayND_closestPtr(self, *args)

	def interpolate1(self, x: 'double const *', xDim: 'unsigned int') -> "double":
	return _npstat.DoubleArrayND_interpolate1(self, x, xDim)

	def interpolate3(self, x: 'double const *', xDim: 'unsigned int') -> "double":
	return _npstat.DoubleArrayND_interpolate3(self, x, xDim)

	def constFill(self, c: 'double') -> "npstat::ArrayND< double > &":
	return _npstat.DoubleArrayND_constFill(self, c)

	def clear(self) -> "npstat::ArrayND< double > &":
	return _npstat.DoubleArrayND_clear(self)

	def linearFill(self, coeff: 'double const *', coeffLen: 'unsigned int', c: 'double') -> "npstat::ArrayND< double > &":
	return _npstat.DoubleArrayND_linearFill(self, coeff, coeffLen, c)

	def makeUnit(self) -> "npstat::ArrayND< double > &":
	return _npstat.DoubleArrayND_makeUnit(self)

	def makeNonNegative(self) -> "npstat::ArrayND< double > &":
	return _npstat.DoubleArrayND_makeNonNegative(self)

	def makeCopulaSteps(self, tolerance: 'double', maxIterations: 'unsigned int') -> "unsigned int":
	return _npstat.DoubleArrayND_makeCopulaSteps(self, tolerance, maxIterations)

	def isCompatible(self, *args) -> "bool":
	return _npstat.DoubleArrayND_isCompatible(self, *args)

	def sliceShape(self, fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayShape":
	return _npstat.DoubleArrayND_sliceShape(self, fixedIndices, nFixedIndices)

	def ptr(self, *args) -> "double const &":
	return _npstat.DoubleArrayND_ptr(self, *args)

	def clPtr(self, *args) -> "double const &":
	return _npstat.DoubleArrayND_clPtr(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleArrayND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleArrayND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleArrayND_classname)
	else:
	classname = _npstat.DoubleArrayND_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleArrayND_version)
	else:
	version = _npstat.DoubleArrayND_version
	if _newclass:
	restore = staticmethod(_npstat.DoubleArrayND_restore)
	else:
	restore = _npstat.DoubleArrayND_restore

	def setValue(self, index: 'unsigned int const *', indexLen: 'unsigned int', v: 'double') -> "void":
	return _npstat.DoubleArrayND_setValue(self, index, indexLen, v)

	def value(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "double":
	return _npstat.DoubleArrayND_value(self, index, indexLen)

	def setLinearValue(self, index: 'unsigned long', v: 'double') -> "void":
	return _npstat.DoubleArrayND_setLinearValue(self, index, v)

	def linearValue(self, index: 'unsigned long') -> "double":
	return _npstat.DoubleArrayND_linearValue(self, index)

	def setClosest(self, x: 'double const *', xDim: 'unsigned int', v: 'double') -> "void":
	return _npstat.DoubleArrayND_setClosest(self, x, xDim, v)

	def closest(self, x: 'double const *', xDim: 'unsigned int') -> "double const":
	return _npstat.DoubleArrayND_closest(self, x, xDim)

	def set(self, *args) -> "void":
	return _npstat.DoubleArrayND_set(self, *args)

	def __call__(self, *args) -> "double":
	return _npstat.DoubleArrayND___call__(self, *args)

	def setCl(self, *args) -> "void":
	return _npstat.DoubleArrayND_setCl(self, *args)

	def cl(self, *args) -> "double":
	return _npstat.DoubleArrayND_cl(self, *args)

	def setData(self, data: 'double const *', dataLength: 'unsigned long') -> "void":
	return _npstat.DoubleArrayND_setData(self, data, dataLength)

	def maxAbsDifference(self, r: 'DoubleArrayND') -> "double":
	return _npstat.DoubleArrayND_maxAbsDifference(self, r)

	def __eq__(self, r: 'DoubleArrayND') -> "bool":
	return _npstat.DoubleArrayND___eq__(self, r)

	def __ne__(self, r: 'DoubleArrayND') -> "bool":
	return _npstat.DoubleArrayND___ne__(self, r)

	def __add__(self, r: 'DoubleArrayND') -> "npstat::ArrayND< double >":
	return _npstat.DoubleArrayND___add__(self, r)

	def __sub__(self, r: 'DoubleArrayND') -> "npstat::ArrayND< double >":
	return _npstat.DoubleArrayND___sub__(self, r)

	def __mul__(self, r: 'double const') -> "npstat::ArrayND< double >":
	return _npstat.DoubleArrayND___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::ArrayND< double >":
	return _npstat.DoubleArrayND___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::ArrayND< double > &":
	return _npstat.DoubleArrayND___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::ArrayND< double > &":
	return _npstat.DoubleArrayND___idiv__(self, r)

	def __iadd__(self, r: 'DoubleArrayND') -> "npstat::ArrayND< double > &":
	return _npstat.DoubleArrayND___iadd__(self, r)

	def __isub__(self, r: 'DoubleArrayND') -> "npstat::ArrayND< double > &":
	return _npstat.DoubleArrayND___isub__(self, r)

	def addmul(self, r: 'DoubleArrayND', c: 'double const') -> "npstat::ArrayND< double > &":
	return _npstat.DoubleArrayND_addmul(self, r, c)

	def inPlaceMul(self, r: 'DoubleArrayND') -> "npstat::ArrayND< double > &":
	return _npstat.DoubleArrayND_inPlaceMul(self, r)

	def outer(self, r: 'DoubleArrayND') -> "npstat::ArrayND< double >":
	return _npstat.DoubleArrayND_outer(self, r)

	def dot(self, r: 'DoubleArrayND') -> "npstat::ArrayND< double >":
	return _npstat.DoubleArrayND_dot(self, r)

	def marginalize(self, r: 'npstat::ArrayND< npstat::ArrayND< double,1U,10U >::proper_double > const &', indexMap: 'unsigned int const *', mapLen: 'unsigned int const') -> "npstat::ArrayND< double >":
	return _npstat.DoubleArrayND_marginalize(self, r, indexMap, mapLen)

	def sum(self) -> "double":
	return _npstat.DoubleArrayND_sum(self)

	def sumsq(self) -> "double":
	return _npstat.DoubleArrayND_sumsq(self)

	def derivative(self, scale: 'double'=1.0) -> "npstat::ArrayND< double >":
	return _npstat.DoubleArrayND_derivative(self, scale)

	def cdfArray(self, scale: 'double'=1.0) -> "npstat::ArrayND< double >":
	return _npstat.DoubleArrayND_cdfArray(self, scale)

	def cdfValue(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "double":
	return _npstat.DoubleArrayND_cdfValue(self, index, indexLen)

	def convertToLastDimCdf(self, sumSlice: 'DoubleArrayND', b: 'bool') -> "void":
	return _npstat.DoubleArrayND_convertToLastDimCdf(self, sumSlice, b)

	def isClose(self, r: 'DoubleArrayND', eps: 'double') -> "bool":
	return _npstat.DoubleArrayND_isClose(self, r, eps)

	def isShapeCompatible(self, r: 'DoubleArrayND') -> "bool":
	return _npstat.DoubleArrayND_isShapeCompatible(self, r)

	def exportSlice(self, slice: 'DoubleArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.DoubleArrayND_exportSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def exportMemSlice(self, slice: 'double ', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const *', nFixedInd: 'unsigned int') -> "void":
	return _npstat.DoubleArrayND_exportMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def importSlice(self, slice: 'DoubleArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.DoubleArrayND_importSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def importMemSlice(self, slice: 'double const ', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const *', nFixedInd: 'unsigned int') -> "void":
	return _npstat.DoubleArrayND_importMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def multiplyBySlice(self, slice: 'npstat::ArrayND< npstat::ArrayND< double,1U,10U >::proper_double > const &', fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayND< double > &":
	return _npstat.DoubleArrayND_multiplyBySlice(self, slice, fixedIndices, nFixedIndices)

	def subrange(self, range: 'ArrayRange') -> "npstat::ArrayND< double >":
	return _npstat.DoubleArrayND_subrange(self, range)

	def slice(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::ArrayND< double >":
	return _npstat.DoubleArrayND_slice(self, index, indexLen)

	def rotate(self, shifts: 'unsigned int const *', lenShifts: 'unsigned int', rotated: 'DoubleArrayND') -> "void":
	return _npstat.DoubleArrayND_rotate(self, shifts, lenShifts, rotated)

	def exportSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', to: 'DoubleArrayND') -> "void":
	return _npstat.DoubleArrayND_exportSubrange(self, corner, lenCorner, to)

	def importSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', arg4: 'DoubleArrayND') -> "void":
	return _npstat.DoubleArrayND_importSubrange(self, corner, lenCorner, arg4)

	def multiMirror(self, out: 'DoubleArrayND') -> "void":
	return _npstat.DoubleArrayND_multiMirror(self, out)

	def __init__(self, *args):
	this = _npstat.new_DoubleArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	DoubleArrayND_swigregister = _npstat.DoubleArrayND_swigregister
	DoubleArrayND_swigregister(DoubleArrayND)

	def DoubleArrayND_classname() -> "char const *":
	return _npstat.DoubleArrayND_classname()
	DoubleArrayND_classname = _npstat.DoubleArrayND_classname

	def DoubleArrayND_version() -> "unsigned int":
	return _npstat.DoubleArrayND_version()
	DoubleArrayND_version = _npstat.DoubleArrayND_version

	def DoubleArrayND_restore(id: 'ClassId', arg3: 'istream', array: 'DoubleArrayND') -> "void":
	return _npstat.DoubleArrayND_restore(id, arg3, array)
	DoubleArrayND_restore = _npstat.DoubleArrayND_restore

	class ArchiveRecord_DoubleArrayND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DoubleArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DoubleArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DoubleArrayND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DoubleArrayND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DoubleArrayND
	__del__ = lambda self: None
	ArchiveRecord_DoubleArrayND_swigregister = _npstat.ArchiveRecord_DoubleArrayND_swigregister
	ArchiveRecord_DoubleArrayND_swigregister(ArchiveRecord_DoubleArrayND)

	class Ref_DoubleArrayND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DoubleArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DoubleArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DoubleArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DoubleArrayND') -> "void":
	return _npstat.Ref_DoubleArrayND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::ArrayND< double,1U,10U > *":
	return _npstat.Ref_DoubleArrayND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::ArrayND< double,1U,10U >":
	return _npstat.Ref_DoubleArrayND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DoubleArrayND
	__del__ = lambda self: None
	Ref_DoubleArrayND_swigregister = _npstat.Ref_DoubleArrayND_swigregister
	Ref_DoubleArrayND_swigregister(Ref_DoubleArrayND)

	class CFloatArrayND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, CFloatArrayND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, CFloatArrayND, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_CFloatArrayND
	__del__ = lambda self: None

	def uninitialize(self) -> "npstat::ArrayND< std::complex< float > > &":
	return _npstat.CFloatArrayND_uninitialize(self)

	def reshape(self, *args) -> "npstat::ArrayND< std::complex< float > > &":
	return _npstat.CFloatArrayND_reshape(self, *args)

	def valueAt(self, *args) -> "std::complex< float > const &":
	return _npstat.CFloatArrayND_valueAt(self, *args)

	def linearPtr(self, *args) -> "std::complex< float > const &":
	return _npstat.CFloatArrayND_linearPtr(self, *args)

	def convertLinearIndex(self, l: 'unsigned long', index: 'unsigned int *', indexLen: 'unsigned int') -> "void":
	return _npstat.CFloatArrayND_convertLinearIndex(self, l, index, indexLen)

	def linearIndex(self, idx: 'unsigned int const *', idxLen: 'unsigned int') -> "unsigned long":
	return _npstat.CFloatArrayND_linearIndex(self, idx, idxLen)

	def length(self) -> "unsigned long":
	return _npstat.CFloatArrayND_length(self)

	def data(self) -> "std::complex< float > const *":
	return _npstat.CFloatArrayND_data(self)

	def isShapeKnown(self) -> "bool":
	return _npstat.CFloatArrayND_isShapeKnown(self)

	def rank(self) -> "unsigned int":
	return _npstat.CFloatArrayND_rank(self)

	def shape(self) -> "npstat::ArrayShape":
	return _npstat.CFloatArrayND_shape(self)

	def shapeData(self) -> "unsigned int const *":
	return _npstat.CFloatArrayND_shapeData(self)

	def fullRange(self) -> "npstat::ArrayRange":
	return _npstat.CFloatArrayND_fullRange(self)

	def span(self, dim: 'unsigned int') -> "unsigned int":
	return _npstat.CFloatArrayND_span(self, dim)

	def maximumSpan(self) -> "unsigned int":
	return _npstat.CFloatArrayND_maximumSpan(self)

	def minimumSpan(self) -> "unsigned int":
	return _npstat.CFloatArrayND_minimumSpan(self)

	def strides(self) -> "unsigned long const *":
	return _npstat.CFloatArrayND_strides(self)

	def isZero(self) -> "bool":
	return _npstat.CFloatArrayND_isZero(self)

	def isDensity(self) -> "bool":
	return _npstat.CFloatArrayND_isDensity(self)

	def __pos__(self) -> "npstat::ArrayND< std::complex< float > >":
	return _npstat.CFloatArrayND___pos__(self)

	def __neg__(self) -> "npstat::ArrayND< std::complex< float > >":
	return _npstat.CFloatArrayND___neg__(self)

	def contract(self, pos1: 'unsigned int', pos2: 'unsigned int') -> "npstat::ArrayND< std::complex< float > >":
	return _npstat.CFloatArrayND_contract(self, pos1, pos2)

	def transpose(self, *args) -> "npstat::ArrayND< std::complex< float > >":
	return _npstat.CFloatArrayND_transpose(self, *args)

	def min(self, *args) -> "std::complex< float >":
	return _npstat.CFloatArrayND_min(self, *args)

	def max(self, *args) -> "std::complex< float >":
	return _npstat.CFloatArrayND_max(self, *args)

	def closestPtr(self, *args) -> "std::complex< float > const &":
	return _npstat.CFloatArrayND_closestPtr(self, *args)

	def interpolate1(self, x: 'double const *', xDim: 'unsigned int') -> "std::complex< float >":
	return _npstat.CFloatArrayND_interpolate1(self, x, xDim)

	def interpolate3(self, x: 'double const *', xDim: 'unsigned int') -> "std::complex< float >":
	return _npstat.CFloatArrayND_interpolate3(self, x, xDim)

	def constFill(self, c: 'std::complex< float >') -> "npstat::ArrayND< std::complex< float > > &":
	return _npstat.CFloatArrayND_constFill(self, c)

	def clear(self) -> "npstat::ArrayND< std::complex< float > > &":
	return _npstat.CFloatArrayND_clear(self)

	def linearFill(self, coeff: 'double const *', coeffLen: 'unsigned int', c: 'double') -> "npstat::ArrayND< std::complex< float > > &":
	return _npstat.CFloatArrayND_linearFill(self, coeff, coeffLen, c)

	def makeUnit(self) -> "npstat::ArrayND< std::complex< float > > &":
	return _npstat.CFloatArrayND_makeUnit(self)

	def makeNonNegative(self) -> "npstat::ArrayND< std::complex< float > > &":
	return _npstat.CFloatArrayND_makeNonNegative(self)

	def makeCopulaSteps(self, tolerance: 'double', maxIterations: 'unsigned int') -> "unsigned int":
	return _npstat.CFloatArrayND_makeCopulaSteps(self, tolerance, maxIterations)

	def isCompatible(self, *args) -> "bool":
	return _npstat.CFloatArrayND_isCompatible(self, *args)

	def sliceShape(self, fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayShape":
	return _npstat.CFloatArrayND_sliceShape(self, fixedIndices, nFixedIndices)

	def ptr(self, *args) -> "std::complex< float > const &":
	return _npstat.CFloatArrayND_ptr(self, *args)

	def clPtr(self, *args) -> "std::complex< float > const &":
	return _npstat.CFloatArrayND_clPtr(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.CFloatArrayND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.CFloatArrayND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.CFloatArrayND_classname)
	else:
	classname = _npstat.CFloatArrayND_classname
	if _newclass:
	version = staticmethod(_npstat.CFloatArrayND_version)
	else:
	version = _npstat.CFloatArrayND_version
	if _newclass:
	restore = staticmethod(_npstat.CFloatArrayND_restore)
	else:
	restore = _npstat.CFloatArrayND_restore

	def setValue(self, index: 'unsigned int const *', indexLen: 'unsigned int', v: 'std::complex< float >') -> "void":
	return _npstat.CFloatArrayND_setValue(self, index, indexLen, v)

	def value(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "std::complex< float >":
	return _npstat.CFloatArrayND_value(self, index, indexLen)

	def setLinearValue(self, index: 'unsigned long', v: 'std::complex< float >') -> "void":
	return _npstat.CFloatArrayND_setLinearValue(self, index, v)

	def linearValue(self, index: 'unsigned long') -> "std::complex< float >":
	return _npstat.CFloatArrayND_linearValue(self, index)

	def setClosest(self, x: 'double const *', xDim: 'unsigned int', v: 'std::complex< float >') -> "void":
	return _npstat.CFloatArrayND_setClosest(self, x, xDim, v)

	def closest(self, x: 'double const *', xDim: 'unsigned int') -> "std::complex< float > const":
	return _npstat.CFloatArrayND_closest(self, x, xDim)

	def set(self, *args) -> "void":
	return _npstat.CFloatArrayND_set(self, *args)

	def __call__(self, *args) -> "std::complex< float >":
	return _npstat.CFloatArrayND___call__(self, *args)

	def setCl(self, *args) -> "void":
	return _npstat.CFloatArrayND_setCl(self, *args)

	def cl(self, *args) -> "std::complex< float >":
	return _npstat.CFloatArrayND_cl(self, *args)

	def setData(self, data: 'std::complex< float > const *', dataLength: 'unsigned long') -> "void":
	return _npstat.CFloatArrayND_setData(self, data, dataLength)

	def maxAbsDifference(self, r: 'CFloatArrayND') -> "double":
	return _npstat.CFloatArrayND_maxAbsDifference(self, r)

	def __eq__(self, r: 'CFloatArrayND') -> "bool":
	return _npstat.CFloatArrayND___eq__(self, r)

	def __ne__(self, r: 'CFloatArrayND') -> "bool":
	return _npstat.CFloatArrayND___ne__(self, r)

	def __add__(self, r: 'CFloatArrayND') -> "npstat::ArrayND< std::complex< float > >":
	return _npstat.CFloatArrayND___add__(self, r)

	def __sub__(self, r: 'CFloatArrayND') -> "npstat::ArrayND< std::complex< float > >":
	return _npstat.CFloatArrayND___sub__(self, r)

	def __mul__(self, r: 'double const') -> "npstat::ArrayND< std::complex< float > >":
	return _npstat.CFloatArrayND___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::ArrayND< std::complex< float > >":
	return _npstat.CFloatArrayND___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::ArrayND< std::complex< float > > &":
	return _npstat.CFloatArrayND___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::ArrayND< std::complex< float > > &":
	return _npstat.CFloatArrayND___idiv__(self, r)

	def __iadd__(self, r: 'CFloatArrayND') -> "npstat::ArrayND< std::complex< float > > &":
	return _npstat.CFloatArrayND___iadd__(self, r)

	def __isub__(self, r: 'CFloatArrayND') -> "npstat::ArrayND< std::complex< float > > &":
	return _npstat.CFloatArrayND___isub__(self, r)

	def addmul(self, r: 'CFloatArrayND', c: 'double const') -> "npstat::ArrayND< std::complex< float > > &":
	return _npstat.CFloatArrayND_addmul(self, r, c)

	def inPlaceMul(self, r: 'CFloatArrayND') -> "npstat::ArrayND< std::complex< float > > &":
	return _npstat.CFloatArrayND_inPlaceMul(self, r)

	def outer(self, r: 'CFloatArrayND') -> "npstat::ArrayND< std::complex< float > >":
	return _npstat.CFloatArrayND_outer(self, r)

	def dot(self, r: 'CFloatArrayND') -> "npstat::ArrayND< std::complex< float > >":
	return _npstat.CFloatArrayND_dot(self, r)

	def marginalize(self, r: 'npstat::ArrayND< npstat::ArrayND< std::complex< float >,1U,10U >::proper_double > const &', indexMap: 'unsigned int const *', mapLen: 'unsigned int const') -> "npstat::ArrayND< std::complex< float > >":
	return _npstat.CFloatArrayND_marginalize(self, r, indexMap, mapLen)

	def sum(self) -> "std::complex< float >":
	return _npstat.CFloatArrayND_sum(self)

	def sumsq(self) -> "double":
	return _npstat.CFloatArrayND_sumsq(self)

	def derivative(self, scale: 'double'=1.0) -> "npstat::ArrayND< std::complex< float > >":
	return _npstat.CFloatArrayND_derivative(self, scale)

	def cdfArray(self, scale: 'double'=1.0) -> "npstat::ArrayND< std::complex< float > >":
	return _npstat.CFloatArrayND_cdfArray(self, scale)

	def cdfValue(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "std::complex< float >":
	return _npstat.CFloatArrayND_cdfValue(self, index, indexLen)

	def convertToLastDimCdf(self, sumSlice: 'CFloatArrayND', b: 'bool') -> "void":
	return _npstat.CFloatArrayND_convertToLastDimCdf(self, sumSlice, b)

	def isClose(self, r: 'CFloatArrayND', eps: 'double') -> "bool":
	return _npstat.CFloatArrayND_isClose(self, r, eps)

	def isShapeCompatible(self, r: 'CFloatArrayND') -> "bool":
	return _npstat.CFloatArrayND_isShapeCompatible(self, r)

	def exportSlice(self, slice: 'CFloatArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.CFloatArrayND_exportSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def exportMemSlice(self, slice: 'std::complex< float > ', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const *', nFixedInd: 'unsigned int') -> "void":
	return _npstat.CFloatArrayND_exportMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def importSlice(self, slice: 'CFloatArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.CFloatArrayND_importSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def importMemSlice(self, slice: 'std::complex< float > const ', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const *', nFixedInd: 'unsigned int') -> "void":
	return _npstat.CFloatArrayND_importMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def multiplyBySlice(self, slice: 'npstat::ArrayND< npstat::ArrayND< std::complex< float >,1U,10U >::proper_double > const &', fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayND< std::complex< float > > &":
	return _npstat.CFloatArrayND_multiplyBySlice(self, slice, fixedIndices, nFixedIndices)

	def subrange(self, range: 'ArrayRange') -> "npstat::ArrayND< std::complex< float > >":
	return _npstat.CFloatArrayND_subrange(self, range)

	def slice(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::ArrayND< std::complex< float > >":
	return _npstat.CFloatArrayND_slice(self, index, indexLen)

	def rotate(self, shifts: 'unsigned int const *', lenShifts: 'unsigned int', rotated: 'CFloatArrayND') -> "void":
	return _npstat.CFloatArrayND_rotate(self, shifts, lenShifts, rotated)

	def exportSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', to: 'CFloatArrayND') -> "void":
	return _npstat.CFloatArrayND_exportSubrange(self, corner, lenCorner, to)

	def importSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', arg4: 'CFloatArrayND') -> "void":
	return _npstat.CFloatArrayND_importSubrange(self, corner, lenCorner, arg4)

	def multiMirror(self, out: 'CFloatArrayND') -> "void":
	return _npstat.CFloatArrayND_multiMirror(self, out)

	def __init__(self, *args):
	this = _npstat.new_CFloatArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	CFloatArrayND_swigregister = _npstat.CFloatArrayND_swigregister
	CFloatArrayND_swigregister(CFloatArrayND)

	def CFloatArrayND_classname() -> "char const *":
	return _npstat.CFloatArrayND_classname()
	CFloatArrayND_classname = _npstat.CFloatArrayND_classname

	def CFloatArrayND_version() -> "unsigned int":
	return _npstat.CFloatArrayND_version()
	CFloatArrayND_version = _npstat.CFloatArrayND_version

	def CFloatArrayND_restore(id: 'ClassId', arg3: 'istream', array: 'CFloatArrayND') -> "void":
	return _npstat.CFloatArrayND_restore(id, arg3, array)
	CFloatArrayND_restore = _npstat.CFloatArrayND_restore

	class CDoubleArrayND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, CDoubleArrayND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, CDoubleArrayND, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_CDoubleArrayND
	__del__ = lambda self: None

	def uninitialize(self) -> "npstat::ArrayND< std::complex< double > > &":
	return _npstat.CDoubleArrayND_uninitialize(self)

	def reshape(self, *args) -> "npstat::ArrayND< std::complex< double > > &":
	return _npstat.CDoubleArrayND_reshape(self, *args)

	def valueAt(self, *args) -> "std::complex< double > const &":
	return _npstat.CDoubleArrayND_valueAt(self, *args)

	def linearPtr(self, *args) -> "std::complex< double > const &":
	return _npstat.CDoubleArrayND_linearPtr(self, *args)

	def convertLinearIndex(self, l: 'unsigned long', index: 'unsigned int *', indexLen: 'unsigned int') -> "void":
	return _npstat.CDoubleArrayND_convertLinearIndex(self, l, index, indexLen)

	def linearIndex(self, idx: 'unsigned int const *', idxLen: 'unsigned int') -> "unsigned long":
	return _npstat.CDoubleArrayND_linearIndex(self, idx, idxLen)

	def length(self) -> "unsigned long":
	return _npstat.CDoubleArrayND_length(self)

	def data(self) -> "std::complex< double > const *":
	return _npstat.CDoubleArrayND_data(self)

	def isShapeKnown(self) -> "bool":
	return _npstat.CDoubleArrayND_isShapeKnown(self)

	def rank(self) -> "unsigned int":
	return _npstat.CDoubleArrayND_rank(self)

	def shape(self) -> "npstat::ArrayShape":
	return _npstat.CDoubleArrayND_shape(self)

	def shapeData(self) -> "unsigned int const *":
	return _npstat.CDoubleArrayND_shapeData(self)

	def fullRange(self) -> "npstat::ArrayRange":
	return _npstat.CDoubleArrayND_fullRange(self)

	def span(self, dim: 'unsigned int') -> "unsigned int":
	return _npstat.CDoubleArrayND_span(self, dim)

	def maximumSpan(self) -> "unsigned int":
	return _npstat.CDoubleArrayND_maximumSpan(self)

	def minimumSpan(self) -> "unsigned int":
	return _npstat.CDoubleArrayND_minimumSpan(self)

	def strides(self) -> "unsigned long const *":
	return _npstat.CDoubleArrayND_strides(self)

	def isZero(self) -> "bool":
	return _npstat.CDoubleArrayND_isZero(self)

	def isDensity(self) -> "bool":
	return _npstat.CDoubleArrayND_isDensity(self)

	def __pos__(self) -> "npstat::ArrayND< std::complex< double > >":
	return _npstat.CDoubleArrayND___pos__(self)

	def __neg__(self) -> "npstat::ArrayND< std::complex< double > >":
	return _npstat.CDoubleArrayND___neg__(self)

	def contract(self, pos1: 'unsigned int', pos2: 'unsigned int') -> "npstat::ArrayND< std::complex< double > >":
	return _npstat.CDoubleArrayND_contract(self, pos1, pos2)

	def transpose(self, *args) -> "npstat::ArrayND< std::complex< double > >":
	return _npstat.CDoubleArrayND_transpose(self, *args)

	def min(self, *args) -> "std::complex< double >":
	return _npstat.CDoubleArrayND_min(self, *args)

	def max(self, *args) -> "std::complex< double >":
	return _npstat.CDoubleArrayND_max(self, *args)

	def closestPtr(self, *args) -> "std::complex< double > const &":
	return _npstat.CDoubleArrayND_closestPtr(self, *args)

	def interpolate1(self, x: 'double const *', xDim: 'unsigned int') -> "std::complex< double >":
	return _npstat.CDoubleArrayND_interpolate1(self, x, xDim)

	def interpolate3(self, x: 'double const *', xDim: 'unsigned int') -> "std::complex< double >":
	return _npstat.CDoubleArrayND_interpolate3(self, x, xDim)

	def constFill(self, c: 'std::complex< double >') -> "npstat::ArrayND< std::complex< double > > &":
	return _npstat.CDoubleArrayND_constFill(self, c)

	def clear(self) -> "npstat::ArrayND< std::complex< double > > &":
	return _npstat.CDoubleArrayND_clear(self)

	def linearFill(self, coeff: 'double const *', coeffLen: 'unsigned int', c: 'double') -> "npstat::ArrayND< std::complex< double > > &":
	return _npstat.CDoubleArrayND_linearFill(self, coeff, coeffLen, c)

	def makeUnit(self) -> "npstat::ArrayND< std::complex< double > > &":
	return _npstat.CDoubleArrayND_makeUnit(self)

	def makeNonNegative(self) -> "npstat::ArrayND< std::complex< double > > &":
	return _npstat.CDoubleArrayND_makeNonNegative(self)

	def makeCopulaSteps(self, tolerance: 'double', maxIterations: 'unsigned int') -> "unsigned int":
	return _npstat.CDoubleArrayND_makeCopulaSteps(self, tolerance, maxIterations)

	def isCompatible(self, *args) -> "bool":
	return _npstat.CDoubleArrayND_isCompatible(self, *args)

	def sliceShape(self, fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayShape":
	return _npstat.CDoubleArrayND_sliceShape(self, fixedIndices, nFixedIndices)

	def ptr(self, *args) -> "std::complex< double > const &":
	return _npstat.CDoubleArrayND_ptr(self, *args)

	def clPtr(self, *args) -> "std::complex< double > const &":
	return _npstat.CDoubleArrayND_clPtr(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.CDoubleArrayND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.CDoubleArrayND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.CDoubleArrayND_classname)
	else:
	classname = _npstat.CDoubleArrayND_classname
	if _newclass:
	version = staticmethod(_npstat.CDoubleArrayND_version)
	else:
	version = _npstat.CDoubleArrayND_version
	if _newclass:
	restore = staticmethod(_npstat.CDoubleArrayND_restore)
	else:
	restore = _npstat.CDoubleArrayND_restore

	def setValue(self, index: 'unsigned int const *', indexLen: 'unsigned int', v: 'std::complex< double >') -> "void":
	return _npstat.CDoubleArrayND_setValue(self, index, indexLen, v)

	def value(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "std::complex< double >":
	return _npstat.CDoubleArrayND_value(self, index, indexLen)

	def setLinearValue(self, index: 'unsigned long', v: 'std::complex< double >') -> "void":
	return _npstat.CDoubleArrayND_setLinearValue(self, index, v)

	def linearValue(self, index: 'unsigned long') -> "std::complex< double >":
	return _npstat.CDoubleArrayND_linearValue(self, index)

	def setClosest(self, x: 'double const *', xDim: 'unsigned int', v: 'std::complex< double >') -> "void":
	return _npstat.CDoubleArrayND_setClosest(self, x, xDim, v)

	def closest(self, x: 'double const *', xDim: 'unsigned int') -> "std::complex< double > const":
	return _npstat.CDoubleArrayND_closest(self, x, xDim)

	def set(self, *args) -> "void":
	return _npstat.CDoubleArrayND_set(self, *args)

	def __call__(self, *args) -> "std::complex< double >":
	return _npstat.CDoubleArrayND___call__(self, *args)

	def setCl(self, *args) -> "void":
	return _npstat.CDoubleArrayND_setCl(self, *args)

	def cl(self, *args) -> "std::complex< double >":
	return _npstat.CDoubleArrayND_cl(self, *args)

	def setData(self, data: 'std::complex< double > const *', dataLength: 'unsigned long') -> "void":
	return _npstat.CDoubleArrayND_setData(self, data, dataLength)

	def maxAbsDifference(self, r: 'CDoubleArrayND') -> "double":
	return _npstat.CDoubleArrayND_maxAbsDifference(self, r)

	def __eq__(self, r: 'CDoubleArrayND') -> "bool":
	return _npstat.CDoubleArrayND___eq__(self, r)

	def __ne__(self, r: 'CDoubleArrayND') -> "bool":
	return _npstat.CDoubleArrayND___ne__(self, r)

	def __add__(self, r: 'CDoubleArrayND') -> "npstat::ArrayND< std::complex< double > >":
	return _npstat.CDoubleArrayND___add__(self, r)

	def __sub__(self, r: 'CDoubleArrayND') -> "npstat::ArrayND< std::complex< double > >":
	return _npstat.CDoubleArrayND___sub__(self, r)

	def __mul__(self, r: 'double const') -> "npstat::ArrayND< std::complex< double > >":
	return _npstat.CDoubleArrayND___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::ArrayND< std::complex< double > >":
	return _npstat.CDoubleArrayND___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::ArrayND< std::complex< double > > &":
	return _npstat.CDoubleArrayND___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::ArrayND< std::complex< double > > &":
	return _npstat.CDoubleArrayND___idiv__(self, r)

	def __iadd__(self, r: 'CDoubleArrayND') -> "npstat::ArrayND< std::complex< double > > &":
	return _npstat.CDoubleArrayND___iadd__(self, r)

	def __isub__(self, r: 'CDoubleArrayND') -> "npstat::ArrayND< std::complex< double > > &":
	return _npstat.CDoubleArrayND___isub__(self, r)

	def addmul(self, r: 'CDoubleArrayND', c: 'double const') -> "npstat::ArrayND< std::complex< double > > &":
	return _npstat.CDoubleArrayND_addmul(self, r, c)

	def inPlaceMul(self, r: 'CDoubleArrayND') -> "npstat::ArrayND< std::complex< double > > &":
	return _npstat.CDoubleArrayND_inPlaceMul(self, r)

	def outer(self, r: 'CDoubleArrayND') -> "npstat::ArrayND< std::complex< double > >":
	return _npstat.CDoubleArrayND_outer(self, r)

	def dot(self, r: 'CDoubleArrayND') -> "npstat::ArrayND< std::complex< double > >":
	return _npstat.CDoubleArrayND_dot(self, r)

	def marginalize(self, r: 'npstat::ArrayND< npstat::ArrayND< std::complex< double >,1U,10U >::proper_double > const &', indexMap: 'unsigned int const *', mapLen: 'unsigned int const') -> "npstat::ArrayND< std::complex< double > >":
	return _npstat.CDoubleArrayND_marginalize(self, r, indexMap, mapLen)

	def sum(self) -> "std::complex< double >":
	return _npstat.CDoubleArrayND_sum(self)

	def sumsq(self) -> "double":
	return _npstat.CDoubleArrayND_sumsq(self)

	def derivative(self, scale: 'double'=1.0) -> "npstat::ArrayND< std::complex< double > >":
	return _npstat.CDoubleArrayND_derivative(self, scale)

	def cdfArray(self, scale: 'double'=1.0) -> "npstat::ArrayND< std::complex< double > >":
	return _npstat.CDoubleArrayND_cdfArray(self, scale)

	def cdfValue(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "std::complex< double >":
	return _npstat.CDoubleArrayND_cdfValue(self, index, indexLen)

	def convertToLastDimCdf(self, sumSlice: 'CDoubleArrayND', b: 'bool') -> "void":
	return _npstat.CDoubleArrayND_convertToLastDimCdf(self, sumSlice, b)

	def isClose(self, r: 'CDoubleArrayND', eps: 'double') -> "bool":
	return _npstat.CDoubleArrayND_isClose(self, r, eps)

	def isShapeCompatible(self, r: 'CDoubleArrayND') -> "bool":
	return _npstat.CDoubleArrayND_isShapeCompatible(self, r)

	def exportSlice(self, slice: 'CDoubleArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.CDoubleArrayND_exportSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def exportMemSlice(self, slice: 'std::complex< double > ', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const *', nFixedInd: 'unsigned int') -> "void":
	return _npstat.CDoubleArrayND_exportMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def importSlice(self, slice: 'CDoubleArrayND', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const ', nFixedInd: 'unsigned int') -> "void":
	return _npstat.CDoubleArrayND_importSlice(self, slice, fixedIndices, fixedIndexValues, nFixedInd)

	def importMemSlice(self, slice: 'std::complex< double > const ', len: 'unsigned long', fixedIndices: 'unsigned int const ', fixedIndexValues: 'unsigned int const *', nFixedInd: 'unsigned int') -> "void":
	return _npstat.CDoubleArrayND_importMemSlice(self, slice, len, fixedIndices, fixedIndexValues, nFixedInd)

	def multiplyBySlice(self, slice: 'npstat::ArrayND< npstat::ArrayND< std::complex< double >,1U,10U >::proper_double > const &', fixedIndices: 'unsigned int const *', nFixedIndices: 'unsigned int') -> "npstat::ArrayND< std::complex< double > > &":
	return _npstat.CDoubleArrayND_multiplyBySlice(self, slice, fixedIndices, nFixedIndices)

	def subrange(self, range: 'ArrayRange') -> "npstat::ArrayND< std::complex< double > >":
	return _npstat.CDoubleArrayND_subrange(self, range)

	def slice(self, index: 'unsigned int const *', indexLen: 'unsigned int') -> "npstat::ArrayND< std::complex< double > >":
	return _npstat.CDoubleArrayND_slice(self, index, indexLen)

	def rotate(self, shifts: 'unsigned int const *', lenShifts: 'unsigned int', rotated: 'CDoubleArrayND') -> "void":
	return _npstat.CDoubleArrayND_rotate(self, shifts, lenShifts, rotated)

	def exportSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', to: 'CDoubleArrayND') -> "void":
	return _npstat.CDoubleArrayND_exportSubrange(self, corner, lenCorner, to)

	def importSubrange(self, corner: 'unsigned int const *', lenCorner: 'unsigned int', arg4: 'CDoubleArrayND') -> "void":
	return _npstat.CDoubleArrayND_importSubrange(self, corner, lenCorner, arg4)

	def multiMirror(self, out: 'CDoubleArrayND') -> "void":
	return _npstat.CDoubleArrayND_multiMirror(self, out)

	def __init__(self, *args):
	this = _npstat.new_CDoubleArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	CDoubleArrayND_swigregister = _npstat.CDoubleArrayND_swigregister
	CDoubleArrayND_swigregister(CDoubleArrayND)

	def CDoubleArrayND_classname() -> "char const *":
	return _npstat.CDoubleArrayND_classname()
	CDoubleArrayND_classname = _npstat.CDoubleArrayND_classname

	def CDoubleArrayND_version() -> "unsigned int":
	return _npstat.CDoubleArrayND_version()
	CDoubleArrayND_version = _npstat.CDoubleArrayND_version

	def CDoubleArrayND_restore(id: 'ClassId', arg3: 'istream', array: 'CDoubleArrayND') -> "void":
	return _npstat.CDoubleArrayND_restore(id, arg3, array)
	CDoubleArrayND_restore = _npstat.CDoubleArrayND_restore

	class ArchiveRecord_CFloatArrayND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_CFloatArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_CFloatArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'CFloatArrayND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_CFloatArrayND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_CFloatArrayND
	__del__ = lambda self: None
	ArchiveRecord_CFloatArrayND_swigregister = _npstat.ArchiveRecord_CFloatArrayND_swigregister
	ArchiveRecord_CFloatArrayND_swigregister(ArchiveRecord_CFloatArrayND)

	class Ref_CFloatArrayND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_CFloatArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_CFloatArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_CFloatArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'CFloatArrayND') -> "void":
	return _npstat.Ref_CFloatArrayND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::ArrayND< std::complex< float >,1U,10U > *":
	return _npstat.Ref_CFloatArrayND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::ArrayND< std::complex< float >,1U,10U >":
	return _npstat.Ref_CFloatArrayND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_CFloatArrayND
	__del__ = lambda self: None
	Ref_CFloatArrayND_swigregister = _npstat.Ref_CFloatArrayND_swigregister
	Ref_CFloatArrayND_swigregister(Ref_CFloatArrayND)

	class ArchiveRecord_CDoubleArrayND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_CDoubleArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_CDoubleArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'CDoubleArrayND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_CDoubleArrayND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_CDoubleArrayND
	__del__ = lambda self: None
	ArchiveRecord_CDoubleArrayND_swigregister = _npstat.ArchiveRecord_CDoubleArrayND_swigregister
	ArchiveRecord_CDoubleArrayND_swigregister(ArchiveRecord_CDoubleArrayND)

	class Ref_CDoubleArrayND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_CDoubleArrayND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_CDoubleArrayND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_CDoubleArrayND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'CDoubleArrayND') -> "void":
	return _npstat.Ref_CDoubleArrayND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::ArrayND< std::complex< double >,1U,10U > *":
	return _npstat.Ref_CDoubleArrayND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::ArrayND< std::complex< double >,1U,10U >":
	return _npstat.Ref_CDoubleArrayND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_CDoubleArrayND
	__del__ = lambda self: None
	Ref_CDoubleArrayND_swigregister = _npstat.Ref_CDoubleArrayND_swigregister
	Ref_CDoubleArrayND_swigregister(Ref_CDoubleArrayND)

	class LinearMapper1d(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LinearMapper1d, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LinearMapper1d, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_LinearMapper1d(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, x: 'double const &') -> "double":
	return _npstat.LinearMapper1d___call__(self, x)

	def a(self) -> "double":
	return _npstat.LinearMapper1d_a(self)

	def b(self) -> "double":
	return _npstat.LinearMapper1d_b(self)

	def inverse(self) -> "npstat::LinearMapper1dTmpl< double >":
	return _npstat.LinearMapper1d_inverse(self)

	def __mul__(self, r: 'LinearMapper1d') -> "npstat::LinearMapper1dTmpl< double >":
	return _npstat.LinearMapper1d___mul__(self, r)
	__swig_destroy__ = _npstat.delete_LinearMapper1d
	__del__ = lambda self: None
	LinearMapper1d_swigregister = _npstat.LinearMapper1d_swigregister
	LinearMapper1d_swigregister(LinearMapper1d)

	class LinearMapper1dVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LinearMapper1dVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LinearMapper1dVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.LinearMapper1dVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.LinearMapper1dVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.LinearMapper1dVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::LinearMapper1dTmpl< double > >::size_type":
	return _npstat.LinearMapper1dVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::LinearMapper1dTmpl< double > >::difference_type', j: 'std::vector< npstat::LinearMapper1dTmpl< double > >::difference_type') -> "std::vector< npstat::LinearMapper1dTmpl< double >,std::allocator< npstat::LinearMapper1dTmpl< double > > > *":
	return _npstat.LinearMapper1dVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.LinearMapper1dVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::LinearMapper1dTmpl< double > >::difference_type', j: 'std::vector< npstat::LinearMapper1dTmpl< double > >::difference_type') -> "void":
	return _npstat.LinearMapper1dVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.LinearMapper1dVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::LinearMapper1dTmpl< double > >::value_type const &":
	return _npstat.LinearMapper1dVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.LinearMapper1dVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::LinearMapper1dTmpl< double > >::value_type":
	return _npstat.LinearMapper1dVector_pop(self)

	def append(self, x: 'LinearMapper1d') -> "void":
	return _npstat.LinearMapper1dVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.LinearMapper1dVector_empty(self)

	def size(self) -> "std::vector< npstat::LinearMapper1dTmpl< double > >::size_type":
	return _npstat.LinearMapper1dVector_size(self)

	def swap(self, v: 'LinearMapper1dVector') -> "void":
	return _npstat.LinearMapper1dVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::LinearMapper1dTmpl< double > >::iterator":
	return _npstat.LinearMapper1dVector_begin(self)

	def end(self) -> "std::vector< npstat::LinearMapper1dTmpl< double > >::iterator":
	return _npstat.LinearMapper1dVector_end(self)

	def rbegin(self) -> "std::vector< npstat::LinearMapper1dTmpl< double > >::reverse_iterator":
	return _npstat.LinearMapper1dVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::LinearMapper1dTmpl< double > >::reverse_iterator":
	return _npstat.LinearMapper1dVector_rend(self)

	def clear(self) -> "void":
	return _npstat.LinearMapper1dVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::LinearMapper1dTmpl< double > >::allocator_type":
	return _npstat.LinearMapper1dVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.LinearMapper1dVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::LinearMapper1dTmpl< double > >::iterator":
	return _npstat.LinearMapper1dVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_LinearMapper1dVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'LinearMapper1d') -> "void":
	return _npstat.LinearMapper1dVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::LinearMapper1dTmpl< double > >::value_type const &":
	return _npstat.LinearMapper1dVector_front(self)

	def back(self) -> "std::vector< npstat::LinearMapper1dTmpl< double > >::value_type const &":
	return _npstat.LinearMapper1dVector_back(self)

	def assign(self, n: 'std::vector< npstat::LinearMapper1dTmpl< double > >::size_type', x: 'LinearMapper1d') -> "void":
	return _npstat.LinearMapper1dVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.LinearMapper1dVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.LinearMapper1dVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::LinearMapper1dTmpl< double > >::size_type') -> "void":
	return _npstat.LinearMapper1dVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::LinearMapper1dTmpl< double > >::size_type":
	return _npstat.LinearMapper1dVector_capacity(self)
	__swig_destroy__ = _npstat.delete_LinearMapper1dVector
	__del__ = lambda self: None
	LinearMapper1dVector_swigregister = _npstat.LinearMapper1dVector_swigregister
	LinearMapper1dVector_swigregister(LinearMapper1dVector)

	class CircularMapper1d(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, CircularMapper1d, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, CircularMapper1d, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_CircularMapper1d(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, x: 'double const &') -> "double":
	return _npstat.CircularMapper1d___call__(self, x)

	def a(self) -> "double":
	return _npstat.CircularMapper1d_a(self)

	def b(self) -> "double":
	return _npstat.CircularMapper1d_b(self)

	def period(self) -> "double":
	return _npstat.CircularMapper1d_period(self)

	def linearMapper(self) -> "npstat::LinearMapper1d":
	return _npstat.CircularMapper1d_linearMapper(self)
	__swig_destroy__ = _npstat.delete_CircularMapper1d
	__del__ = lambda self: None
	CircularMapper1d_swigregister = _npstat.CircularMapper1d_swigregister
	CircularMapper1d_swigregister(CircularMapper1d)

	class CircularMapper1dVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, CircularMapper1dVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, CircularMapper1dVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.CircularMapper1dVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.CircularMapper1dVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.CircularMapper1dVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::CircularMapper1d >::size_type":
	return _npstat.CircularMapper1dVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::CircularMapper1d >::difference_type', j: 'std::vector< npstat::CircularMapper1d >::difference_type') -> "std::vector< npstat::CircularMapper1d,std::allocator< npstat::CircularMapper1d > > *":
	return _npstat.CircularMapper1dVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.CircularMapper1dVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::CircularMapper1d >::difference_type', j: 'std::vector< npstat::CircularMapper1d >::difference_type') -> "void":
	return _npstat.CircularMapper1dVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.CircularMapper1dVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::CircularMapper1d >::value_type const &":
	return _npstat.CircularMapper1dVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.CircularMapper1dVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::CircularMapper1d >::value_type":
	return _npstat.CircularMapper1dVector_pop(self)

	def append(self, x: 'CircularMapper1d') -> "void":
	return _npstat.CircularMapper1dVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.CircularMapper1dVector_empty(self)

	def size(self) -> "std::vector< npstat::CircularMapper1d >::size_type":
	return _npstat.CircularMapper1dVector_size(self)

	def swap(self, v: 'CircularMapper1dVector') -> "void":
	return _npstat.CircularMapper1dVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::CircularMapper1d >::iterator":
	return _npstat.CircularMapper1dVector_begin(self)

	def end(self) -> "std::vector< npstat::CircularMapper1d >::iterator":
	return _npstat.CircularMapper1dVector_end(self)

	def rbegin(self) -> "std::vector< npstat::CircularMapper1d >::reverse_iterator":
	return _npstat.CircularMapper1dVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::CircularMapper1d >::reverse_iterator":
	return _npstat.CircularMapper1dVector_rend(self)

	def clear(self) -> "void":
	return _npstat.CircularMapper1dVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::CircularMapper1d >::allocator_type":
	return _npstat.CircularMapper1dVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.CircularMapper1dVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::CircularMapper1d >::iterator":
	return _npstat.CircularMapper1dVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_CircularMapper1dVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'CircularMapper1d') -> "void":
	return _npstat.CircularMapper1dVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::CircularMapper1d >::value_type const &":
	return _npstat.CircularMapper1dVector_front(self)

	def back(self) -> "std::vector< npstat::CircularMapper1d >::value_type const &":
	return _npstat.CircularMapper1dVector_back(self)

	def assign(self, n: 'std::vector< npstat::CircularMapper1d >::size_type', x: 'CircularMapper1d') -> "void":
	return _npstat.CircularMapper1dVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.CircularMapper1dVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.CircularMapper1dVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::CircularMapper1d >::size_type') -> "void":
	return _npstat.CircularMapper1dVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::CircularMapper1d >::size_type":
	return _npstat.CircularMapper1dVector_capacity(self)
	__swig_destroy__ = _npstat.delete_CircularMapper1dVector
	__del__ = lambda self: None
	CircularMapper1dVector_swigregister = _npstat.CircularMapper1dVector_swigregister
	CircularMapper1dVector_swigregister(CircularMapper1dVector)

	class HistoAxis(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, HistoAxis, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, HistoAxis, name)
	__repr__ = _swig_repr

	def min(self) -> "double":
	return _npstat.HistoAxis_min(self)

	def max(self) -> "double":
	return _npstat.HistoAxis_max(self)

	def interval(self) -> "npstat::Interval< double >":
	return _npstat.HistoAxis_interval(self)

	def length(self) -> "double":
	return _npstat.HistoAxis_length(self)

	def nBins(self) -> "unsigned int":
	return _npstat.HistoAxis_nBins(self)

	def binWidth(self, arg2: 'int const'=0) -> "double":
	return _npstat.HistoAxis_binWidth(self, arg2)

	def label(self) -> "std::string const &":
	return _npstat.HistoAxis_label(self)

	def isUniform(self) -> "bool":
	return _npstat.HistoAxis_isUniform(self)

	def binCenter(self, binNum: 'int const') -> "double":
	return _npstat.HistoAxis_binCenter(self, binNum)

	def leftBinEdge(self, binNum: 'int const') -> "double":
	return _npstat.HistoAxis_leftBinEdge(self, binNum)

	def rightBinEdge(self, binNum: 'int const') -> "double":
	return _npstat.HistoAxis_rightBinEdge(self, binNum)

	def binInterval(self, binNum: 'int const') -> "npstat::Interval< double >":
	return _npstat.HistoAxis_binInterval(self, binNum)

	def setLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.HistoAxis_setLabel(self, newlabel)

	def binNumber(self, x: 'double') -> "int":
	return _npstat.HistoAxis_binNumber(self, x)

	def closestValidBin(self, x: 'double') -> "unsigned int":
	return _npstat.HistoAxis_closestValidBin(self, x)

	def binNumberMapper(self, mapLeftEdgeTo0: 'bool'=True) -> "npstat::LinearMapper1d":
	return _npstat.HistoAxis_binNumberMapper(self, mapLeftEdgeTo0)

	def fltBinNumber(self, x: 'double const', mapLeftEdgeTo0: 'bool const'=True) -> "double":
	return _npstat.HistoAxis_fltBinNumber(self, x, mapLeftEdgeTo0)

	def kernelScanMapper(self, doubleRange: 'bool') -> "npstat::CircularMapper1d":
	return _npstat.HistoAxis_kernelScanMapper(self, doubleRange)

	def __eq__(self, arg2: 'HistoAxis') -> "bool":
	return _npstat.HistoAxis___eq__(self, arg2)

	def __ne__(self, arg2: 'HistoAxis') -> "bool":
	return _npstat.HistoAxis___ne__(self, arg2)

	def isClose(self, arg2: 'HistoAxis', tol: 'double') -> "bool":
	return _npstat.HistoAxis_isClose(self, arg2, tol)

	def rebin(self, newBins: 'unsigned int') -> "npstat::HistoAxis":
	return _npstat.HistoAxis_rebin(self, newBins)

	def classId(self) -> "gs::ClassId":
	return _npstat.HistoAxis_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.HistoAxis_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.HistoAxis_classname)
	else:
	classname = _npstat.HistoAxis_classname
	if _newclass:
	version = staticmethod(_npstat.HistoAxis_version)
	else:
	version = _npstat.HistoAxis_version
	if _newclass:
	read = staticmethod(_npstat.HistoAxis_read)
	else:
	read = _npstat.HistoAxis_read

	def range(self) -> "std::pair< double,double >":
	return _npstat.HistoAxis_range(self)

	def __init__(self, *args):
	this = _npstat.new_HistoAxis(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def binCenters(self) -> "std::vector< double,std::allocator< double > >":
	return _npstat.HistoAxis_binCenters(self)

	def binEdges(self) -> "std::vector< double,std::allocator< double > >":
	return _npstat.HistoAxis_binEdges(self)
	__swig_destroy__ = _npstat.delete_HistoAxis
	__del__ = lambda self: None
	HistoAxis_swigregister = _npstat.HistoAxis_swigregister
	HistoAxis_swigregister(HistoAxis)

	def HistoAxis_classname() -> "char const *":
	return _npstat.HistoAxis_classname()
	HistoAxis_classname = _npstat.HistoAxis_classname

	def HistoAxis_version() -> "unsigned int":
	return _npstat.HistoAxis_version()
	HistoAxis_version = _npstat.HistoAxis_version

	def HistoAxis_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoAxis *":
	return _npstat.HistoAxis_read(id, arg3)
	HistoAxis_read = _npstat.HistoAxis_read

	class HistoAxisVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, HistoAxisVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, HistoAxisVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.HistoAxisVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.HistoAxisVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.HistoAxisVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::HistoAxis >::size_type":
	return _npstat.HistoAxisVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::HistoAxis >::difference_type', j: 'std::vector< npstat::HistoAxis >::difference_type') -> "std::vector< npstat::HistoAxis,std::allocator< npstat::HistoAxis > > *":
	return _npstat.HistoAxisVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.HistoAxisVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::HistoAxis >::difference_type', j: 'std::vector< npstat::HistoAxis >::difference_type') -> "void":
	return _npstat.HistoAxisVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.HistoAxisVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::HistoAxis >::value_type const &":
	return _npstat.HistoAxisVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.HistoAxisVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::HistoAxis >::value_type":
	return _npstat.HistoAxisVector_pop(self)

	def append(self, x: 'HistoAxis') -> "void":
	return _npstat.HistoAxisVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.HistoAxisVector_empty(self)

	def size(self) -> "std::vector< npstat::HistoAxis >::size_type":
	return _npstat.HistoAxisVector_size(self)

	def swap(self, v: 'HistoAxisVector') -> "void":
	return _npstat.HistoAxisVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::HistoAxis >::iterator":
	return _npstat.HistoAxisVector_begin(self)

	def end(self) -> "std::vector< npstat::HistoAxis >::iterator":
	return _npstat.HistoAxisVector_end(self)

	def rbegin(self) -> "std::vector< npstat::HistoAxis >::reverse_iterator":
	return _npstat.HistoAxisVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::HistoAxis >::reverse_iterator":
	return _npstat.HistoAxisVector_rend(self)

	def clear(self) -> "void":
	return _npstat.HistoAxisVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::HistoAxis >::allocator_type":
	return _npstat.HistoAxisVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.HistoAxisVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::HistoAxis >::iterator":
	return _npstat.HistoAxisVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_HistoAxisVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'HistoAxis') -> "void":
	return _npstat.HistoAxisVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::HistoAxis >::value_type const &":
	return _npstat.HistoAxisVector_front(self)

	def back(self) -> "std::vector< npstat::HistoAxis >::value_type const &":
	return _npstat.HistoAxisVector_back(self)

	def assign(self, n: 'std::vector< npstat::HistoAxis >::size_type', x: 'HistoAxis') -> "void":
	return _npstat.HistoAxisVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.HistoAxisVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.HistoAxisVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::HistoAxis >::size_type') -> "void":
	return _npstat.HistoAxisVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::HistoAxis >::size_type":
	return _npstat.HistoAxisVector_capacity(self)
	__swig_destroy__ = _npstat.delete_HistoAxisVector
	__del__ = lambda self: None
	HistoAxisVector_swigregister = _npstat.HistoAxisVector_swigregister
	HistoAxisVector_swigregister(HistoAxisVector)

	class NUHistoAxis(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, NUHistoAxis, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, NUHistoAxis, name)
	__repr__ = _swig_repr

	def min(self) -> "double":
	return _npstat.NUHistoAxis_min(self)

	def max(self) -> "double":
	return _npstat.NUHistoAxis_max(self)

	def interval(self) -> "npstat::Interval< double >":
	return _npstat.NUHistoAxis_interval(self)

	def length(self) -> "double":
	return _npstat.NUHistoAxis_length(self)

	def nBins(self) -> "unsigned int":
	return _npstat.NUHistoAxis_nBins(self)

	def binWidth(self, binNum: 'int const') -> "double":
	return _npstat.NUHistoAxis_binWidth(self, binNum)

	def label(self) -> "std::string const &":
	return _npstat.NUHistoAxis_label(self)

	def isUniform(self) -> "bool":
	return _npstat.NUHistoAxis_isUniform(self)

	def leftBinEdge(self, binNum: 'int const') -> "double":
	return _npstat.NUHistoAxis_leftBinEdge(self, binNum)

	def rightBinEdge(self, binNum: 'int const') -> "double":
	return _npstat.NUHistoAxis_rightBinEdge(self, binNum)

	def binCenter(self, binNum: 'int const') -> "double":
	return _npstat.NUHistoAxis_binCenter(self, binNum)

	def binInterval(self, binNum: 'int const') -> "npstat::Interval< double >":
	return _npstat.NUHistoAxis_binInterval(self, binNum)

	def setLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.NUHistoAxis_setLabel(self, newlabel)

	def binNumber(self, x: 'double') -> "int":
	return _npstat.NUHistoAxis_binNumber(self, x)

	def fltBinNumber(self, x: 'double', mapLeftEdgeTo0: 'bool'=True) -> "double":
	return _npstat.NUHistoAxis_fltBinNumber(self, x, mapLeftEdgeTo0)

	def closestValidBin(self, x: 'double') -> "unsigned int":
	return _npstat.NUHistoAxis_closestValidBin(self, x)

	def __eq__(self, arg2: 'NUHistoAxis') -> "bool":
	return _npstat.NUHistoAxis___eq__(self, arg2)

	def __ne__(self, arg2: 'NUHistoAxis') -> "bool":
	return _npstat.NUHistoAxis___ne__(self, arg2)

	def isClose(self, arg2: 'NUHistoAxis', tol: 'double') -> "bool":
	return _npstat.NUHistoAxis_isClose(self, arg2, tol)

	def rebin(self, newBins: 'unsigned int') -> "npstat::NUHistoAxis":
	return _npstat.NUHistoAxis_rebin(self, newBins)

	def classId(self) -> "gs::ClassId":
	return _npstat.NUHistoAxis_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.NUHistoAxis_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.NUHistoAxis_classname)
	else:
	classname = _npstat.NUHistoAxis_classname
	if _newclass:
	version = staticmethod(_npstat.NUHistoAxis_version)
	else:
	version = _npstat.NUHistoAxis_version
	if _newclass:
	read = staticmethod(_npstat.NUHistoAxis_read)
	else:
	read = _npstat.NUHistoAxis_read

	def range(self) -> "std::pair< double,double >":
	return _npstat.NUHistoAxis_range(self)

	def __init__(self, *args):
	this = _npstat.new_NUHistoAxis(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def binCenters(self) -> "std::vector< double,std::allocator< double > >":
	return _npstat.NUHistoAxis_binCenters(self)

	def binEdges(self) -> "std::vector< double,std::allocator< double > >":
	return _npstat.NUHistoAxis_binEdges(self)
	__swig_destroy__ = _npstat.delete_NUHistoAxis
	__del__ = lambda self: None
	NUHistoAxis_swigregister = _npstat.NUHistoAxis_swigregister
	NUHistoAxis_swigregister(NUHistoAxis)

	def NUHistoAxis_classname() -> "char const *":
	return _npstat.NUHistoAxis_classname()
	NUHistoAxis_classname = _npstat.NUHistoAxis_classname

	def NUHistoAxis_version() -> "unsigned int":
	return _npstat.NUHistoAxis_version()
	NUHistoAxis_version = _npstat.NUHistoAxis_version

	def NUHistoAxis_read(id: 'ClassId', arg3: 'istream') -> "npstat::NUHistoAxis *":
	return _npstat.NUHistoAxis_read(id, arg3)
	NUHistoAxis_read = _npstat.NUHistoAxis_read

	class NUHistoAxisVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, NUHistoAxisVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, NUHistoAxisVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.NUHistoAxisVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.NUHistoAxisVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.NUHistoAxisVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::NUHistoAxis >::size_type":
	return _npstat.NUHistoAxisVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::NUHistoAxis >::difference_type', j: 'std::vector< npstat::NUHistoAxis >::difference_type') -> "std::vector< npstat::NUHistoAxis,std::allocator< npstat::NUHistoAxis > > *":
	return _npstat.NUHistoAxisVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.NUHistoAxisVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::NUHistoAxis >::difference_type', j: 'std::vector< npstat::NUHistoAxis >::difference_type') -> "void":
	return _npstat.NUHistoAxisVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.NUHistoAxisVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::NUHistoAxis >::value_type const &":
	return _npstat.NUHistoAxisVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.NUHistoAxisVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::NUHistoAxis >::value_type":
	return _npstat.NUHistoAxisVector_pop(self)

	def append(self, x: 'NUHistoAxis') -> "void":
	return _npstat.NUHistoAxisVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.NUHistoAxisVector_empty(self)

	def size(self) -> "std::vector< npstat::NUHistoAxis >::size_type":
	return _npstat.NUHistoAxisVector_size(self)

	def swap(self, v: 'NUHistoAxisVector') -> "void":
	return _npstat.NUHistoAxisVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::NUHistoAxis >::iterator":
	return _npstat.NUHistoAxisVector_begin(self)

	def end(self) -> "std::vector< npstat::NUHistoAxis >::iterator":
	return _npstat.NUHistoAxisVector_end(self)

	def rbegin(self) -> "std::vector< npstat::NUHistoAxis >::reverse_iterator":
	return _npstat.NUHistoAxisVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::NUHistoAxis >::reverse_iterator":
	return _npstat.NUHistoAxisVector_rend(self)

	def clear(self) -> "void":
	return _npstat.NUHistoAxisVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::NUHistoAxis >::allocator_type":
	return _npstat.NUHistoAxisVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.NUHistoAxisVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::NUHistoAxis >::iterator":
	return _npstat.NUHistoAxisVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_NUHistoAxisVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'NUHistoAxis') -> "void":
	return _npstat.NUHistoAxisVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::NUHistoAxis >::value_type const &":
	return _npstat.NUHistoAxisVector_front(self)

	def back(self) -> "std::vector< npstat::NUHistoAxis >::value_type const &":
	return _npstat.NUHistoAxisVector_back(self)

	def assign(self, n: 'std::vector< npstat::NUHistoAxis >::size_type', x: 'NUHistoAxis') -> "void":
	return _npstat.NUHistoAxisVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.NUHistoAxisVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.NUHistoAxisVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::NUHistoAxis >::size_type') -> "void":
	return _npstat.NUHistoAxisVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::NUHistoAxis >::size_type":
	return _npstat.NUHistoAxisVector_capacity(self)
	__swig_destroy__ = _npstat.delete_NUHistoAxisVector
	__del__ = lambda self: None
	NUHistoAxisVector_swigregister = _npstat.NUHistoAxisVector_swigregister
	NUHistoAxisVector_swigregister(NUHistoAxisVector)

	class DualHistoAxis(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DualHistoAxis, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DualHistoAxis, name)
	__repr__ = _swig_repr

	def isUniform(self) -> "bool":
	return _npstat.DualHistoAxis_isUniform(self)

	def min(self) -> "double":
	return _npstat.DualHistoAxis_min(self)

	def max(self) -> "double":
	return _npstat.DualHistoAxis_max(self)

	def interval(self) -> "npstat::Interval< double >":
	return _npstat.DualHistoAxis_interval(self)

	def length(self) -> "double":
	return _npstat.DualHistoAxis_length(self)

	def nBins(self) -> "unsigned int":
	return _npstat.DualHistoAxis_nBins(self)

	def binWidth(self, binNum: 'int const') -> "double":
	return _npstat.DualHistoAxis_binWidth(self, binNum)

	def label(self) -> "std::string const &":
	return _npstat.DualHistoAxis_label(self)

	def binCenter(self, binNum: 'int const') -> "double":
	return _npstat.DualHistoAxis_binCenter(self, binNum)

	def leftBinEdge(self, binNum: 'int const') -> "double":
	return _npstat.DualHistoAxis_leftBinEdge(self, binNum)

	def rightBinEdge(self, binNum: 'int const') -> "double":
	return _npstat.DualHistoAxis_rightBinEdge(self, binNum)

	def binInterval(self, binNum: 'int const') -> "npstat::Interval< double >":
	return _npstat.DualHistoAxis_binInterval(self, binNum)

	def getNUHistoAxis(self) -> "npstat::NUHistoAxis const *":
	return _npstat.DualHistoAxis_getNUHistoAxis(self)

	def getHistoAxis(self) -> "npstat::HistoAxis const *":
	return _npstat.DualHistoAxis_getHistoAxis(self)

	def setLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.DualHistoAxis_setLabel(self, newlabel)

	def binNumber(self, x: 'double const') -> "int":
	return _npstat.DualHistoAxis_binNumber(self, x)

	def fltBinNumber(self, x: 'double const', mapLeftEdgeTo0: 'bool const'=True) -> "double":
	return _npstat.DualHistoAxis_fltBinNumber(self, x, mapLeftEdgeTo0)

	def closestValidBin(self, x: 'double const') -> "unsigned int":
	return _npstat.DualHistoAxis_closestValidBin(self, x)

	def __eq__(self, r: 'DualHistoAxis') -> "bool":
	return _npstat.DualHistoAxis___eq__(self, r)

	def __ne__(self, r: 'DualHistoAxis') -> "bool":
	return _npstat.DualHistoAxis___ne__(self, r)

	def isClose(self, r: 'DualHistoAxis', tol: 'double const') -> "bool":
	return _npstat.DualHistoAxis_isClose(self, r, tol)

	def rebin(self, newBins: 'unsigned int const') -> "npstat::DualHistoAxis":
	return _npstat.DualHistoAxis_rebin(self, newBins)

	def classId(self) -> "gs::ClassId":
	return _npstat.DualHistoAxis_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DualHistoAxis_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DualHistoAxis_classname)
	else:
	classname = _npstat.DualHistoAxis_classname
	if _newclass:
	version = staticmethod(_npstat.DualHistoAxis_version)
	else:
	version = _npstat.DualHistoAxis_version
	if _newclass:
	read = staticmethod(_npstat.DualHistoAxis_read)
	else:
	read = _npstat.DualHistoAxis_read

	def range(self) -> "std::pair< double,double >":
	return _npstat.DualHistoAxis_range(self)

	def __init__(self, *args):
	this = _npstat.new_DualHistoAxis(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def binCenters(self) -> "std::vector< double,std::allocator< double > >":
	return _npstat.DualHistoAxis_binCenters(self)

	def binEdges(self) -> "std::vector< double,std::allocator< double > >":
	return _npstat.DualHistoAxis_binEdges(self)
	__swig_destroy__ = _npstat.delete_DualHistoAxis
	__del__ = lambda self: None
	DualHistoAxis_swigregister = _npstat.DualHistoAxis_swigregister
	DualHistoAxis_swigregister(DualHistoAxis)

	def DualHistoAxis_classname() -> "char const *":
	return _npstat.DualHistoAxis_classname()
	DualHistoAxis_classname = _npstat.DualHistoAxis_classname

	def DualHistoAxis_version() -> "unsigned int":
	return _npstat.DualHistoAxis_version()
	DualHistoAxis_version = _npstat.DualHistoAxis_version

	def DualHistoAxis_read(id: 'ClassId', arg3: 'istream') -> "npstat::DualHistoAxis *":
	return _npstat.DualHistoAxis_read(id, arg3)
	DualHistoAxis_read = _npstat.DualHistoAxis_read

	class DualHistoAxisVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DualHistoAxisVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DualHistoAxisVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.DualHistoAxisVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.DualHistoAxisVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.DualHistoAxisVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::DualHistoAxis >::size_type":
	return _npstat.DualHistoAxisVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::DualHistoAxis >::difference_type', j: 'std::vector< npstat::DualHistoAxis >::difference_type') -> "std::vector< npstat::DualHistoAxis,std::allocator< npstat::DualHistoAxis > > *":
	return _npstat.DualHistoAxisVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.DualHistoAxisVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::DualHistoAxis >::difference_type', j: 'std::vector< npstat::DualHistoAxis >::difference_type') -> "void":
	return _npstat.DualHistoAxisVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.DualHistoAxisVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::DualHistoAxis >::value_type const &":
	return _npstat.DualHistoAxisVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.DualHistoAxisVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::DualHistoAxis >::value_type":
	return _npstat.DualHistoAxisVector_pop(self)

	def append(self, x: 'DualHistoAxis') -> "void":
	return _npstat.DualHistoAxisVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.DualHistoAxisVector_empty(self)

	def size(self) -> "std::vector< npstat::DualHistoAxis >::size_type":
	return _npstat.DualHistoAxisVector_size(self)

	def swap(self, v: 'DualHistoAxisVector') -> "void":
	return _npstat.DualHistoAxisVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::DualHistoAxis >::iterator":
	return _npstat.DualHistoAxisVector_begin(self)

	def end(self) -> "std::vector< npstat::DualHistoAxis >::iterator":
	return _npstat.DualHistoAxisVector_end(self)

	def rbegin(self) -> "std::vector< npstat::DualHistoAxis >::reverse_iterator":
	return _npstat.DualHistoAxisVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::DualHistoAxis >::reverse_iterator":
	return _npstat.DualHistoAxisVector_rend(self)

	def clear(self) -> "void":
	return _npstat.DualHistoAxisVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::DualHistoAxis >::allocator_type":
	return _npstat.DualHistoAxisVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.DualHistoAxisVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::DualHistoAxis >::iterator":
	return _npstat.DualHistoAxisVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_DualHistoAxisVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'DualHistoAxis') -> "void":
	return _npstat.DualHistoAxisVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::DualHistoAxis >::value_type const &":
	return _npstat.DualHistoAxisVector_front(self)

	def back(self) -> "std::vector< npstat::DualHistoAxis >::value_type const &":
	return _npstat.DualHistoAxisVector_back(self)

	def assign(self, n: 'std::vector< npstat::DualHistoAxis >::size_type', x: 'DualHistoAxis') -> "void":
	return _npstat.DualHistoAxisVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.DualHistoAxisVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.DualHistoAxisVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::DualHistoAxis >::size_type') -> "void":
	return _npstat.DualHistoAxisVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::DualHistoAxis >::size_type":
	return _npstat.DualHistoAxisVector_capacity(self)
	__swig_destroy__ = _npstat.delete_DualHistoAxisVector
	__del__ = lambda self: None
	DualHistoAxisVector_swigregister = _npstat.DualHistoAxisVector_swigregister
	DualHistoAxisVector_swigregister(DualHistoAxisVector)

	class IntHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.IntHistoND_SAMPLE
	SUM = _npstat.IntHistoND_SUM
	AVERAGE = _npstat.IntHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_IntHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.IntHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.IntHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.IntHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< int > const &":
	return _npstat.IntHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< int > const &":
	return _npstat.IntHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::HistoAxis,std::allocator< npstat::HistoAxis > > const &":
	return _npstat.IntHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::HistoAxis const &":
	return _npstat.IntHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.IntHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.IntHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.IntHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.IntHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.IntHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.IntHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.IntHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.IntHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.IntHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.IntHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.IntHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.IntHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.IntHistoND_volume(self)

	def integral(self) -> "double":
	return _npstat.IntHistoND_integral(self)

	def clear(self) -> "void":
	return _npstat.IntHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.IntHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.IntHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'IntHistoND') -> "bool":
	return _npstat.IntHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'IntHistoND') -> "bool":
	return _npstat.IntHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'IntHistoND') -> "bool":
	return _npstat.IntHistoND_isSameData(self, arg2)

	def recalculateNFillsFromData(self) -> "void":
	return _npstat.IntHistoND_recalculateNFillsFromData(self)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.IntHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.IntHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< int,npstat::HistoAxis >":
	return _npstat.IntHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.IntHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.IntHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.IntHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.IntHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.IntHistoND_classname)
	else:
	classname = _npstat.IntHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.IntHistoND_version)
	else:
	version = _npstat.IntHistoND_version
	if _newclass:
	read = staticmethod(_npstat.IntHistoND_read)
	else:
	read = _npstat.IntHistoND_read

	def examine(self, *args) -> "int":
	return _npstat.IntHistoND_examine(self, *args)

	def closestBin(self, *args) -> "int":
	return _npstat.IntHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.IntHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'int') -> "void":
	return _npstat.IntHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'int const') -> "void":
	return _npstat.IntHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'int const') -> "void":
	return _npstat.IntHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.IntHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_IntHistoND
	__del__ = lambda self: None
	IntHistoND_swigregister = _npstat.IntHistoND_swigregister
	IntHistoND_swigregister(IntHistoND)

	def IntHistoND_classname() -> "char const *":
	return _npstat.IntHistoND_classname()
	IntHistoND_classname = _npstat.IntHistoND_classname

	def IntHistoND_version() -> "unsigned int":
	return _npstat.IntHistoND_version()
	IntHistoND_version = _npstat.IntHistoND_version

	def IntHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< int,npstat::HistoAxis > *":
	return _npstat.IntHistoND_read(id, arg3)
	IntHistoND_read = _npstat.IntHistoND_read

	class LLongHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.LLongHistoND_SAMPLE
	SUM = _npstat.LLongHistoND_SUM
	AVERAGE = _npstat.LLongHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_LLongHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.LLongHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.LLongHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.LLongHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< long long > const &":
	return _npstat.LLongHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< long long > const &":
	return _npstat.LLongHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::HistoAxis,std::allocator< npstat::HistoAxis > > const &":
	return _npstat.LLongHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::HistoAxis const &":
	return _npstat.LLongHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.LLongHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.LLongHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.LLongHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.LLongHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.LLongHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.LLongHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.LLongHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.LLongHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.LLongHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.LLongHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.LLongHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.LLongHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.LLongHistoND_volume(self)

	def integral(self) -> "double":
	return _npstat.LLongHistoND_integral(self)

	def clear(self) -> "void":
	return _npstat.LLongHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.LLongHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.LLongHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'LLongHistoND') -> "bool":
	return _npstat.LLongHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'LLongHistoND') -> "bool":
	return _npstat.LLongHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'LLongHistoND') -> "bool":
	return _npstat.LLongHistoND_isSameData(self, arg2)

	def recalculateNFillsFromData(self) -> "void":
	return _npstat.LLongHistoND_recalculateNFillsFromData(self)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.LLongHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.LLongHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< long long,npstat::HistoAxis >":
	return _npstat.LLongHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.LLongHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.LLongHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.LLongHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.LLongHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.LLongHistoND_classname)
	else:
	classname = _npstat.LLongHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.LLongHistoND_version)
	else:
	version = _npstat.LLongHistoND_version
	if _newclass:
	read = staticmethod(_npstat.LLongHistoND_read)
	else:
	read = _npstat.LLongHistoND_read

	def examine(self, *args) -> "long long":
	return _npstat.LLongHistoND_examine(self, *args)

	def closestBin(self, *args) -> "long long":
	return _npstat.LLongHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.LLongHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'long long') -> "void":
	return _npstat.LLongHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'long long const') -> "void":
	return _npstat.LLongHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'long long const') -> "void":
	return _npstat.LLongHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.LLongHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_LLongHistoND
	__del__ = lambda self: None
	LLongHistoND_swigregister = _npstat.LLongHistoND_swigregister
	LLongHistoND_swigregister(LLongHistoND)

	def LLongHistoND_classname() -> "char const *":
	return _npstat.LLongHistoND_classname()
	LLongHistoND_classname = _npstat.LLongHistoND_classname

	def LLongHistoND_version() -> "unsigned int":
	return _npstat.LLongHistoND_version()
	LLongHistoND_version = _npstat.LLongHistoND_version

	def LLongHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< long long,npstat::HistoAxis > *":
	return _npstat.LLongHistoND_read(id, arg3)
	LLongHistoND_read = _npstat.LLongHistoND_read

	class UCharHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.UCharHistoND_SAMPLE
	SUM = _npstat.UCharHistoND_SUM
	AVERAGE = _npstat.UCharHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_UCharHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.UCharHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.UCharHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.UCharHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< unsigned char > const &":
	return _npstat.UCharHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< unsigned char > const &":
	return _npstat.UCharHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::HistoAxis,std::allocator< npstat::HistoAxis > > const &":
	return _npstat.UCharHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::HistoAxis const &":
	return _npstat.UCharHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.UCharHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.UCharHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.UCharHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.UCharHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.UCharHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.UCharHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.UCharHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.UCharHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.UCharHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.UCharHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.UCharHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.UCharHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.UCharHistoND_volume(self)

	def integral(self) -> "double":
	return _npstat.UCharHistoND_integral(self)

	def clear(self) -> "void":
	return _npstat.UCharHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.UCharHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.UCharHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'UCharHistoND') -> "bool":
	return _npstat.UCharHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'UCharHistoND') -> "bool":
	return _npstat.UCharHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'UCharHistoND') -> "bool":
	return _npstat.UCharHistoND_isSameData(self, arg2)

	def recalculateNFillsFromData(self) -> "void":
	return _npstat.UCharHistoND_recalculateNFillsFromData(self)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.UCharHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.UCharHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< unsigned char,npstat::HistoAxis >":
	return _npstat.UCharHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.UCharHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.UCharHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.UCharHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.UCharHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.UCharHistoND_classname)
	else:
	classname = _npstat.UCharHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.UCharHistoND_version)
	else:
	version = _npstat.UCharHistoND_version
	if _newclass:
	read = staticmethod(_npstat.UCharHistoND_read)
	else:
	read = _npstat.UCharHistoND_read

	def examine(self, *args) -> "unsigned char":
	return _npstat.UCharHistoND_examine(self, *args)

	def closestBin(self, *args) -> "unsigned char":
	return _npstat.UCharHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.UCharHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'unsigned char') -> "void":
	return _npstat.UCharHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'unsigned char const') -> "void":
	return _npstat.UCharHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'unsigned char const') -> "void":
	return _npstat.UCharHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.UCharHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_UCharHistoND
	__del__ = lambda self: None
	UCharHistoND_swigregister = _npstat.UCharHistoND_swigregister
	UCharHistoND_swigregister(UCharHistoND)

	def UCharHistoND_classname() -> "char const *":
	return _npstat.UCharHistoND_classname()
	UCharHistoND_classname = _npstat.UCharHistoND_classname

	def UCharHistoND_version() -> "unsigned int":
	return _npstat.UCharHistoND_version()
	UCharHistoND_version = _npstat.UCharHistoND_version

	def UCharHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< unsigned char,npstat::HistoAxis > *":
	return _npstat.UCharHistoND_read(id, arg3)
	UCharHistoND_read = _npstat.UCharHistoND_read

	class FloatHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.FloatHistoND_SAMPLE
	SUM = _npstat.FloatHistoND_SUM
	AVERAGE = _npstat.FloatHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_FloatHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.FloatHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.FloatHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.FloatHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< float > const &":
	return _npstat.FloatHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< float > const &":
	return _npstat.FloatHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::HistoAxis,std::allocator< npstat::HistoAxis > > const &":
	return _npstat.FloatHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::HistoAxis const &":
	return _npstat.FloatHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.FloatHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.FloatHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.FloatHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.FloatHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.FloatHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.FloatHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.FloatHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.FloatHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.FloatHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.FloatHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.FloatHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.FloatHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.FloatHistoND_volume(self)

	def integral(self) -> "double":
	return _npstat.FloatHistoND_integral(self)

	def clear(self) -> "void":
	return _npstat.FloatHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.FloatHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.FloatHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'FloatHistoND') -> "bool":
	return _npstat.FloatHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'FloatHistoND') -> "bool":
	return _npstat.FloatHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'FloatHistoND') -> "bool":
	return _npstat.FloatHistoND_isSameData(self, arg2)

	def recalculateNFillsFromData(self) -> "void":
	return _npstat.FloatHistoND_recalculateNFillsFromData(self)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.FloatHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.FloatHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< float,npstat::HistoAxis >":
	return _npstat.FloatHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.FloatHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.FloatHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatHistoND_classname)
	else:
	classname = _npstat.FloatHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.FloatHistoND_version)
	else:
	version = _npstat.FloatHistoND_version
	if _newclass:
	read = staticmethod(_npstat.FloatHistoND_read)
	else:
	read = _npstat.FloatHistoND_read

	def examine(self, *args) -> "float":
	return _npstat.FloatHistoND_examine(self, *args)

	def closestBin(self, *args) -> "float":
	return _npstat.FloatHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.FloatHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'float') -> "void":
	return _npstat.FloatHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'float const') -> "void":
	return _npstat.FloatHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'float const') -> "void":
	return _npstat.FloatHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.FloatHistoND_fill(self, *args)

	def fillC(self, *args) -> "void":
	return _npstat.FloatHistoND_fillC(self, *args)
	__swig_destroy__ = _npstat.delete_FloatHistoND
	__del__ = lambda self: None
	FloatHistoND_swigregister = _npstat.FloatHistoND_swigregister
	FloatHistoND_swigregister(FloatHistoND)

	def FloatHistoND_classname() -> "char const *":
	return _npstat.FloatHistoND_classname()
	FloatHistoND_classname = _npstat.FloatHistoND_classname

	def FloatHistoND_version() -> "unsigned int":
	return _npstat.FloatHistoND_version()
	FloatHistoND_version = _npstat.FloatHistoND_version

	def FloatHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< float,npstat::HistoAxis > *":
	return _npstat.FloatHistoND_read(id, arg3)
	FloatHistoND_read = _npstat.FloatHistoND_read

	class DoubleHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.DoubleHistoND_SAMPLE
	SUM = _npstat.DoubleHistoND_SUM
	AVERAGE = _npstat.DoubleHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_DoubleHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.DoubleHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.DoubleHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.DoubleHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< double > const &":
	return _npstat.DoubleHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< double > const &":
	return _npstat.DoubleHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::HistoAxis,std::allocator< npstat::HistoAxis > > const &":
	return _npstat.DoubleHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::HistoAxis const &":
	return _npstat.DoubleHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.DoubleHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.DoubleHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.DoubleHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.DoubleHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.DoubleHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.DoubleHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.DoubleHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.DoubleHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.DoubleHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.DoubleHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.DoubleHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.DoubleHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.DoubleHistoND_volume(self)

	def integral(self) -> "double":
	return _npstat.DoubleHistoND_integral(self)

	def clear(self) -> "void":
	return _npstat.DoubleHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.DoubleHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.DoubleHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'DoubleHistoND') -> "bool":
	return _npstat.DoubleHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'DoubleHistoND') -> "bool":
	return _npstat.DoubleHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'DoubleHistoND') -> "bool":
	return _npstat.DoubleHistoND_isSameData(self, arg2)

	def recalculateNFillsFromData(self) -> "void":
	return _npstat.DoubleHistoND_recalculateNFillsFromData(self)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.DoubleHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.DoubleHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< double,npstat::HistoAxis >":
	return _npstat.DoubleHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.DoubleHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.DoubleHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleHistoND_classname)
	else:
	classname = _npstat.DoubleHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleHistoND_version)
	else:
	version = _npstat.DoubleHistoND_version
	if _newclass:
	read = staticmethod(_npstat.DoubleHistoND_read)
	else:
	read = _npstat.DoubleHistoND_read

	def examine(self, *args) -> "double":
	return _npstat.DoubleHistoND_examine(self, *args)

	def closestBin(self, *args) -> "double":
	return _npstat.DoubleHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.DoubleHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'double') -> "void":
	return _npstat.DoubleHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'double const') -> "void":
	return _npstat.DoubleHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'double const') -> "void":
	return _npstat.DoubleHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.DoubleHistoND_fill(self, *args)

	def fillC(self, *args) -> "void":
	return _npstat.DoubleHistoND_fillC(self, *args)
	__swig_destroy__ = _npstat.delete_DoubleHistoND
	__del__ = lambda self: None
	DoubleHistoND_swigregister = _npstat.DoubleHistoND_swigregister
	DoubleHistoND_swigregister(DoubleHistoND)

	def DoubleHistoND_classname() -> "char const *":
	return _npstat.DoubleHistoND_classname()
	DoubleHistoND_classname = _npstat.DoubleHistoND_classname

	def DoubleHistoND_version() -> "unsigned int":
	return _npstat.DoubleHistoND_version()
	DoubleHistoND_version = _npstat.DoubleHistoND_version

	def DoubleHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< double,npstat::HistoAxis > *":
	return _npstat.DoubleHistoND_read(id, arg3)
	DoubleHistoND_read = _npstat.DoubleHistoND_read

	class StatAccHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, StatAccHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, StatAccHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.StatAccHistoND_SAMPLE
	SUM = _npstat.StatAccHistoND_SUM
	AVERAGE = _npstat.StatAccHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_StatAccHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.StatAccHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.StatAccHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.StatAccHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::StatAccumulator > const &":
	return _npstat.StatAccHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::StatAccumulator > const &":
	return _npstat.StatAccHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::HistoAxis,std::allocator< npstat::HistoAxis > > const &":
	return _npstat.StatAccHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::HistoAxis const &":
	return _npstat.StatAccHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.StatAccHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.StatAccHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.StatAccHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.StatAccHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.StatAccHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.StatAccHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.StatAccHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.StatAccHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.StatAccHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.StatAccHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.StatAccHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.StatAccHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.StatAccHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.StatAccHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.StatAccHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.StatAccHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'StatAccHistoND') -> "bool":
	return _npstat.StatAccHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'StatAccHistoND') -> "bool":
	return _npstat.StatAccHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'StatAccHistoND') -> "bool":
	return _npstat.StatAccHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.StatAccHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.StatAccHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::StatAccumulator,npstat::HistoAxis >":
	return _npstat.StatAccHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.StatAccHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.StatAccHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.StatAccHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.StatAccHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.StatAccHistoND_classname)
	else:
	classname = _npstat.StatAccHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.StatAccHistoND_version)
	else:
	version = _npstat.StatAccHistoND_version
	if _newclass:
	read = staticmethod(_npstat.StatAccHistoND_read)
	else:
	read = _npstat.StatAccHistoND_read

	def examine(self, *args) -> "npstat::StatAccumulator":
	return _npstat.StatAccHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::StatAccumulator":
	return _npstat.StatAccHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.StatAccHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'StatAccumulator') -> "void":
	return _npstat.StatAccHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'StatAccumulator') -> "void":
	return _npstat.StatAccHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'StatAccumulator') -> "void":
	return _npstat.StatAccHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.StatAccHistoND_fill(self, *args)

	def fillC(self, *args) -> "void":
	return _npstat.StatAccHistoND_fillC(self, *args)
	__swig_destroy__ = _npstat.delete_StatAccHistoND
	__del__ = lambda self: None
	StatAccHistoND_swigregister = _npstat.StatAccHistoND_swigregister
	StatAccHistoND_swigregister(StatAccHistoND)

	def StatAccHistoND_classname() -> "char const *":
	return _npstat.StatAccHistoND_classname()
	StatAccHistoND_classname = _npstat.StatAccHistoND_classname

	def StatAccHistoND_version() -> "unsigned int":
	return _npstat.StatAccHistoND_version()
	StatAccHistoND_version = _npstat.StatAccHistoND_version

	def StatAccHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::StatAccumulator,npstat::HistoAxis > *":
	return _npstat.StatAccHistoND_read(id, arg3)
	StatAccHistoND_read = _npstat.StatAccHistoND_read

	class WStatAccHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, WStatAccHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, WStatAccHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.WStatAccHistoND_SAMPLE
	SUM = _npstat.WStatAccHistoND_SUM
	AVERAGE = _npstat.WStatAccHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_WStatAccHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.WStatAccHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.WStatAccHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.WStatAccHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::WeightedStatAccumulator > const &":
	return _npstat.WStatAccHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::WeightedStatAccumulator > const &":
	return _npstat.WStatAccHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::HistoAxis,std::allocator< npstat::HistoAxis > > const &":
	return _npstat.WStatAccHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::HistoAxis const &":
	return _npstat.WStatAccHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.WStatAccHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.WStatAccHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.WStatAccHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.WStatAccHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.WStatAccHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.WStatAccHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.WStatAccHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.WStatAccHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.WStatAccHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.WStatAccHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.WStatAccHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.WStatAccHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.WStatAccHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.WStatAccHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.WStatAccHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.WStatAccHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'WStatAccHistoND') -> "bool":
	return _npstat.WStatAccHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'WStatAccHistoND') -> "bool":
	return _npstat.WStatAccHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'WStatAccHistoND') -> "bool":
	return _npstat.WStatAccHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.WStatAccHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.WStatAccHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::WeightedStatAccumulator,npstat::HistoAxis >":
	return _npstat.WStatAccHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.WStatAccHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.WStatAccHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.WStatAccHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.WStatAccHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.WStatAccHistoND_classname)
	else:
	classname = _npstat.WStatAccHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.WStatAccHistoND_version)
	else:
	version = _npstat.WStatAccHistoND_version
	if _newclass:
	read = staticmethod(_npstat.WStatAccHistoND_read)
	else:
	read = _npstat.WStatAccHistoND_read

	def examine(self, *args) -> "npstat::WeightedStatAccumulator":
	return _npstat.WStatAccHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::WeightedStatAccumulator":
	return _npstat.WStatAccHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.WStatAccHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'WeightedStatAccumulator') -> "void":
	return _npstat.WStatAccHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'WeightedStatAccumulator') -> "void":
	return _npstat.WStatAccHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'WeightedStatAccumulator') -> "void":
	return _npstat.WStatAccHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.WStatAccHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_WStatAccHistoND
	__del__ = lambda self: None
	WStatAccHistoND_swigregister = _npstat.WStatAccHistoND_swigregister
	WStatAccHistoND_swigregister(WStatAccHistoND)

	def WStatAccHistoND_classname() -> "char const *":
	return _npstat.WStatAccHistoND_classname()
	WStatAccHistoND_classname = _npstat.WStatAccHistoND_classname

	def WStatAccHistoND_version() -> "unsigned int":
	return _npstat.WStatAccHistoND_version()
	WStatAccHistoND_version = _npstat.WStatAccHistoND_version

	def WStatAccHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::WeightedStatAccumulator,npstat::HistoAxis > *":
	return _npstat.WStatAccHistoND_read(id, arg3)
	WStatAccHistoND_read = _npstat.WStatAccHistoND_read

	class BinSummaryHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, BinSummaryHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, BinSummaryHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.BinSummaryHistoND_SAMPLE
	SUM = _npstat.BinSummaryHistoND_SUM
	AVERAGE = _npstat.BinSummaryHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_BinSummaryHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.BinSummaryHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.BinSummaryHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.BinSummaryHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::BinSummary > const &":
	return _npstat.BinSummaryHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::BinSummary > const &":
	return _npstat.BinSummaryHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::HistoAxis,std::allocator< npstat::HistoAxis > > const &":
	return _npstat.BinSummaryHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::HistoAxis const &":
	return _npstat.BinSummaryHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.BinSummaryHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.BinSummaryHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.BinSummaryHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.BinSummaryHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.BinSummaryHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.BinSummaryHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.BinSummaryHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.BinSummaryHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.BinSummaryHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.BinSummaryHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.BinSummaryHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.BinSummaryHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.BinSummaryHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.BinSummaryHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.BinSummaryHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.BinSummaryHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'BinSummaryHistoND') -> "bool":
	return _npstat.BinSummaryHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'BinSummaryHistoND') -> "bool":
	return _npstat.BinSummaryHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'BinSummaryHistoND') -> "bool":
	return _npstat.BinSummaryHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.BinSummaryHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.BinSummaryHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::BinSummary,npstat::HistoAxis >":
	return _npstat.BinSummaryHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.BinSummaryHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.BinSummaryHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.BinSummaryHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.BinSummaryHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.BinSummaryHistoND_classname)
	else:
	classname = _npstat.BinSummaryHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.BinSummaryHistoND_version)
	else:
	version = _npstat.BinSummaryHistoND_version
	if _newclass:
	read = staticmethod(_npstat.BinSummaryHistoND_read)
	else:
	read = _npstat.BinSummaryHistoND_read

	def examine(self, *args) -> "npstat::BinSummary":
	return _npstat.BinSummaryHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::BinSummary":
	return _npstat.BinSummaryHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.BinSummaryHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'BinSummary') -> "void":
	return _npstat.BinSummaryHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'BinSummary') -> "void":
	return _npstat.BinSummaryHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'BinSummary') -> "void":
	return _npstat.BinSummaryHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.BinSummaryHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_BinSummaryHistoND
	__del__ = lambda self: None
	BinSummaryHistoND_swigregister = _npstat.BinSummaryHistoND_swigregister
	BinSummaryHistoND_swigregister(BinSummaryHistoND)

	def BinSummaryHistoND_classname() -> "char const *":
	return _npstat.BinSummaryHistoND_classname()
	BinSummaryHistoND_classname = _npstat.BinSummaryHistoND_classname

	def BinSummaryHistoND_version() -> "unsigned int":
	return _npstat.BinSummaryHistoND_version()
	BinSummaryHistoND_version = _npstat.BinSummaryHistoND_version

	def BinSummaryHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::BinSummary,npstat::HistoAxis > *":
	return _npstat.BinSummaryHistoND_read(id, arg3)
	BinSummaryHistoND_read = _npstat.BinSummaryHistoND_read

	class FSampleAccHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FSampleAccHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FSampleAccHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.FSampleAccHistoND_SAMPLE
	SUM = _npstat.FSampleAccHistoND_SUM
	AVERAGE = _npstat.FSampleAccHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_FSampleAccHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.FSampleAccHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.FSampleAccHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.FSampleAccHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::SampleAccumulator< float,long double > > const &":
	return _npstat.FSampleAccHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::SampleAccumulator< float,long double > > const &":
	return _npstat.FSampleAccHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::HistoAxis,std::allocator< npstat::HistoAxis > > const &":
	return _npstat.FSampleAccHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::HistoAxis const &":
	return _npstat.FSampleAccHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.FSampleAccHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.FSampleAccHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.FSampleAccHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.FSampleAccHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.FSampleAccHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.FSampleAccHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.FSampleAccHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.FSampleAccHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.FSampleAccHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.FSampleAccHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.FSampleAccHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.FSampleAccHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.FSampleAccHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.FSampleAccHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.FSampleAccHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.FSampleAccHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'FSampleAccHistoND') -> "bool":
	return _npstat.FSampleAccHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'FSampleAccHistoND') -> "bool":
	return _npstat.FSampleAccHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'FSampleAccHistoND') -> "bool":
	return _npstat.FSampleAccHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.FSampleAccHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.FSampleAccHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::FloatSampleAccumulator,npstat::HistoAxis >":
	return _npstat.FSampleAccHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.FSampleAccHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.FSampleAccHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.FSampleAccHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FSampleAccHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FSampleAccHistoND_classname)
	else:
	classname = _npstat.FSampleAccHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.FSampleAccHistoND_version)
	else:
	version = _npstat.FSampleAccHistoND_version
	if _newclass:
	read = staticmethod(_npstat.FSampleAccHistoND_read)
	else:
	read = _npstat.FSampleAccHistoND_read

	def examine(self, *args) -> "npstat::SampleAccumulator< float,long double >":
	return _npstat.FSampleAccHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::SampleAccumulator< float,long double >":
	return _npstat.FSampleAccHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.FSampleAccHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'FloatSampleAccumulator') -> "void":
	return _npstat.FSampleAccHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'FloatSampleAccumulator') -> "void":
	return _npstat.FSampleAccHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'FloatSampleAccumulator') -> "void":
	return _npstat.FSampleAccHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.FSampleAccHistoND_fill(self, *args)

	def fillC(self, *args) -> "void":
	return _npstat.FSampleAccHistoND_fillC(self, *args)
	__swig_destroy__ = _npstat.delete_FSampleAccHistoND
	__del__ = lambda self: None
	FSampleAccHistoND_swigregister = _npstat.FSampleAccHistoND_swigregister
	FSampleAccHistoND_swigregister(FSampleAccHistoND)

	def FSampleAccHistoND_classname() -> "char const *":
	return _npstat.FSampleAccHistoND_classname()
	FSampleAccHistoND_classname = _npstat.FSampleAccHistoND_classname

	def FSampleAccHistoND_version() -> "unsigned int":
	return _npstat.FSampleAccHistoND_version()
	FSampleAccHistoND_version = _npstat.FSampleAccHistoND_version

	def FSampleAccHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::FloatSampleAccumulator,npstat::HistoAxis > *":
	return _npstat.FSampleAccHistoND_read(id, arg3)
	FSampleAccHistoND_read = _npstat.FSampleAccHistoND_read

	class DSampleAccHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DSampleAccHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DSampleAccHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.DSampleAccHistoND_SAMPLE
	SUM = _npstat.DSampleAccHistoND_SUM
	AVERAGE = _npstat.DSampleAccHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_DSampleAccHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.DSampleAccHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.DSampleAccHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.DSampleAccHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::SampleAccumulator< double,long double > > const &":
	return _npstat.DSampleAccHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::SampleAccumulator< double,long double > > const &":
	return _npstat.DSampleAccHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::HistoAxis,std::allocator< npstat::HistoAxis > > const &":
	return _npstat.DSampleAccHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::HistoAxis const &":
	return _npstat.DSampleAccHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.DSampleAccHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.DSampleAccHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.DSampleAccHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.DSampleAccHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.DSampleAccHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.DSampleAccHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.DSampleAccHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.DSampleAccHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.DSampleAccHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.DSampleAccHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.DSampleAccHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.DSampleAccHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.DSampleAccHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.DSampleAccHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.DSampleAccHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.DSampleAccHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'DSampleAccHistoND') -> "bool":
	return _npstat.DSampleAccHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'DSampleAccHistoND') -> "bool":
	return _npstat.DSampleAccHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'DSampleAccHistoND') -> "bool":
	return _npstat.DSampleAccHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.DSampleAccHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.DSampleAccHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::HistoAxis >":
	return _npstat.DSampleAccHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.DSampleAccHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.DSampleAccHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.DSampleAccHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DSampleAccHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DSampleAccHistoND_classname)
	else:
	classname = _npstat.DSampleAccHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.DSampleAccHistoND_version)
	else:
	version = _npstat.DSampleAccHistoND_version
	if _newclass:
	read = staticmethod(_npstat.DSampleAccHistoND_read)
	else:
	read = _npstat.DSampleAccHistoND_read

	def examine(self, *args) -> "npstat::SampleAccumulator< double,long double >":
	return _npstat.DSampleAccHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::SampleAccumulator< double,long double >":
	return _npstat.DSampleAccHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.DSampleAccHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'DoubleSampleAccumulator') -> "void":
	return _npstat.DSampleAccHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'DoubleSampleAccumulator') -> "void":
	return _npstat.DSampleAccHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'DoubleSampleAccumulator') -> "void":
	return _npstat.DSampleAccHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.DSampleAccHistoND_fill(self, *args)

	def fillC(self, *args) -> "void":
	return _npstat.DSampleAccHistoND_fillC(self, *args)
	__swig_destroy__ = _npstat.delete_DSampleAccHistoND
	__del__ = lambda self: None
	DSampleAccHistoND_swigregister = _npstat.DSampleAccHistoND_swigregister
	DSampleAccHistoND_swigregister(DSampleAccHistoND)

	def DSampleAccHistoND_classname() -> "char const *":
	return _npstat.DSampleAccHistoND_classname()
	DSampleAccHistoND_classname = _npstat.DSampleAccHistoND_classname

	def DSampleAccHistoND_version() -> "unsigned int":
	return _npstat.DSampleAccHistoND_version()
	DSampleAccHistoND_version = _npstat.DSampleAccHistoND_version

	def DSampleAccHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::HistoAxis > *":
	return _npstat.DSampleAccHistoND_read(id, arg3)
	DSampleAccHistoND_read = _npstat.DSampleAccHistoND_read

	class DWSampleAccHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DWSampleAccHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DWSampleAccHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.DWSampleAccHistoND_SAMPLE
	SUM = _npstat.DWSampleAccHistoND_SUM
	AVERAGE = _npstat.DWSampleAccHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_DWSampleAccHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.DWSampleAccHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.DWSampleAccHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.DWSampleAccHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::WeightedSampleAccumulator< double,long double > > const &":
	return _npstat.DWSampleAccHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::WeightedSampleAccumulator< double,long double > > const &":
	return _npstat.DWSampleAccHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::HistoAxis,std::allocator< npstat::HistoAxis > > const &":
	return _npstat.DWSampleAccHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::HistoAxis const &":
	return _npstat.DWSampleAccHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.DWSampleAccHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.DWSampleAccHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.DWSampleAccHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.DWSampleAccHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.DWSampleAccHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.DWSampleAccHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.DWSampleAccHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.DWSampleAccHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.DWSampleAccHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.DWSampleAccHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.DWSampleAccHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.DWSampleAccHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.DWSampleAccHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.DWSampleAccHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.DWSampleAccHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.DWSampleAccHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'DWSampleAccHistoND') -> "bool":
	return _npstat.DWSampleAccHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'DWSampleAccHistoND') -> "bool":
	return _npstat.DWSampleAccHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'DWSampleAccHistoND') -> "bool":
	return _npstat.DWSampleAccHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.DWSampleAccHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.DWSampleAccHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::HistoAxis >":
	return _npstat.DWSampleAccHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.DWSampleAccHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.DWSampleAccHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.DWSampleAccHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DWSampleAccHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DWSampleAccHistoND_classname)
	else:
	classname = _npstat.DWSampleAccHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.DWSampleAccHistoND_version)
	else:
	version = _npstat.DWSampleAccHistoND_version
	if _newclass:
	read = staticmethod(_npstat.DWSampleAccHistoND_read)
	else:
	read = _npstat.DWSampleAccHistoND_read

	def examine(self, *args) -> "npstat::WeightedSampleAccumulator< double,long double >":
	return _npstat.DWSampleAccHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::WeightedSampleAccumulator< double,long double >":
	return _npstat.DWSampleAccHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.DWSampleAccHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'DoubleWeightedSampleAccumulator') -> "void":
	return _npstat.DWSampleAccHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'DoubleWeightedSampleAccumulator') -> "void":
	return _npstat.DWSampleAccHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'DoubleWeightedSampleAccumulator') -> "void":
	return _npstat.DWSampleAccHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.DWSampleAccHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_DWSampleAccHistoND
	__del__ = lambda self: None
	DWSampleAccHistoND_swigregister = _npstat.DWSampleAccHistoND_swigregister
	DWSampleAccHistoND_swigregister(DWSampleAccHistoND)

	def DWSampleAccHistoND_classname() -> "char const *":
	return _npstat.DWSampleAccHistoND_classname()
	DWSampleAccHistoND_classname = _npstat.DWSampleAccHistoND_classname

	def DWSampleAccHistoND_version() -> "unsigned int":
	return _npstat.DWSampleAccHistoND_version()
	DWSampleAccHistoND_version = _npstat.DWSampleAccHistoND_version

	def DWSampleAccHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::HistoAxis > *":
	return _npstat.DWSampleAccHistoND_read(id, arg3)
	DWSampleAccHistoND_read = _npstat.DWSampleAccHistoND_read

	class IntNUHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntNUHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntNUHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.IntNUHistoND_SAMPLE
	SUM = _npstat.IntNUHistoND_SUM
	AVERAGE = _npstat.IntNUHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_IntNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.IntNUHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.IntNUHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.IntNUHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< int > const &":
	return _npstat.IntNUHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< int > const &":
	return _npstat.IntNUHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::NUHistoAxis,std::allocator< npstat::NUHistoAxis > > const &":
	return _npstat.IntNUHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::NUHistoAxis const &":
	return _npstat.IntNUHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.IntNUHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.IntNUHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.IntNUHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.IntNUHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.IntNUHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.IntNUHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.IntNUHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.IntNUHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.IntNUHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.IntNUHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.IntNUHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.IntNUHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.IntNUHistoND_volume(self)

	def integral(self) -> "double":
	return _npstat.IntNUHistoND_integral(self)

	def clear(self) -> "void":
	return _npstat.IntNUHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.IntNUHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.IntNUHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'IntNUHistoND') -> "bool":
	return _npstat.IntNUHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'IntNUHistoND') -> "bool":
	return _npstat.IntNUHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'IntNUHistoND') -> "bool":
	return _npstat.IntNUHistoND_isSameData(self, arg2)

	def recalculateNFillsFromData(self) -> "void":
	return _npstat.IntNUHistoND_recalculateNFillsFromData(self)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.IntNUHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.IntNUHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< int,npstat::NUHistoAxis >":
	return _npstat.IntNUHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.IntNUHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.IntNUHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.IntNUHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.IntNUHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.IntNUHistoND_classname)
	else:
	classname = _npstat.IntNUHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.IntNUHistoND_version)
	else:
	version = _npstat.IntNUHistoND_version
	if _newclass:
	read = staticmethod(_npstat.IntNUHistoND_read)
	else:
	read = _npstat.IntNUHistoND_read

	def examine(self, *args) -> "int":
	return _npstat.IntNUHistoND_examine(self, *args)

	def closestBin(self, *args) -> "int":
	return _npstat.IntNUHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.IntNUHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'int') -> "void":
	return _npstat.IntNUHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'int const') -> "void":
	return _npstat.IntNUHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'int const') -> "void":
	return _npstat.IntNUHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.IntNUHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_IntNUHistoND
	__del__ = lambda self: None
	IntNUHistoND_swigregister = _npstat.IntNUHistoND_swigregister
	IntNUHistoND_swigregister(IntNUHistoND)

	def IntNUHistoND_classname() -> "char const *":
	return _npstat.IntNUHistoND_classname()
	IntNUHistoND_classname = _npstat.IntNUHistoND_classname

	def IntNUHistoND_version() -> "unsigned int":
	return _npstat.IntNUHistoND_version()
	IntNUHistoND_version = _npstat.IntNUHistoND_version

	def IntNUHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< int,npstat::NUHistoAxis > *":
	return _npstat.IntNUHistoND_read(id, arg3)
	IntNUHistoND_read = _npstat.IntNUHistoND_read

	class LLongNUHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongNUHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongNUHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.LLongNUHistoND_SAMPLE
	SUM = _npstat.LLongNUHistoND_SUM
	AVERAGE = _npstat.LLongNUHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_LLongNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.LLongNUHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.LLongNUHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.LLongNUHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< long long > const &":
	return _npstat.LLongNUHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< long long > const &":
	return _npstat.LLongNUHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::NUHistoAxis,std::allocator< npstat::NUHistoAxis > > const &":
	return _npstat.LLongNUHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::NUHistoAxis const &":
	return _npstat.LLongNUHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.LLongNUHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.LLongNUHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.LLongNUHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.LLongNUHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.LLongNUHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.LLongNUHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.LLongNUHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.LLongNUHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.LLongNUHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.LLongNUHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.LLongNUHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.LLongNUHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.LLongNUHistoND_volume(self)

	def integral(self) -> "double":
	return _npstat.LLongNUHistoND_integral(self)

	def clear(self) -> "void":
	return _npstat.LLongNUHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.LLongNUHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.LLongNUHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'LLongNUHistoND') -> "bool":
	return _npstat.LLongNUHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'LLongNUHistoND') -> "bool":
	return _npstat.LLongNUHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'LLongNUHistoND') -> "bool":
	return _npstat.LLongNUHistoND_isSameData(self, arg2)

	def recalculateNFillsFromData(self) -> "void":
	return _npstat.LLongNUHistoND_recalculateNFillsFromData(self)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.LLongNUHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.LLongNUHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< long long,npstat::NUHistoAxis >":
	return _npstat.LLongNUHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.LLongNUHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.LLongNUHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.LLongNUHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.LLongNUHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.LLongNUHistoND_classname)
	else:
	classname = _npstat.LLongNUHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.LLongNUHistoND_version)
	else:
	version = _npstat.LLongNUHistoND_version
	if _newclass:
	read = staticmethod(_npstat.LLongNUHistoND_read)
	else:
	read = _npstat.LLongNUHistoND_read

	def examine(self, *args) -> "long long":
	return _npstat.LLongNUHistoND_examine(self, *args)

	def closestBin(self, *args) -> "long long":
	return _npstat.LLongNUHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.LLongNUHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'long long') -> "void":
	return _npstat.LLongNUHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'long long const') -> "void":
	return _npstat.LLongNUHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'long long const') -> "void":
	return _npstat.LLongNUHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.LLongNUHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_LLongNUHistoND
	__del__ = lambda self: None
	LLongNUHistoND_swigregister = _npstat.LLongNUHistoND_swigregister
	LLongNUHistoND_swigregister(LLongNUHistoND)

	def LLongNUHistoND_classname() -> "char const *":
	return _npstat.LLongNUHistoND_classname()
	LLongNUHistoND_classname = _npstat.LLongNUHistoND_classname

	def LLongNUHistoND_version() -> "unsigned int":
	return _npstat.LLongNUHistoND_version()
	LLongNUHistoND_version = _npstat.LLongNUHistoND_version

	def LLongNUHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< long long,npstat::NUHistoAxis > *":
	return _npstat.LLongNUHistoND_read(id, arg3)
	LLongNUHistoND_read = _npstat.LLongNUHistoND_read

	class UCharNUHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharNUHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharNUHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.UCharNUHistoND_SAMPLE
	SUM = _npstat.UCharNUHistoND_SUM
	AVERAGE = _npstat.UCharNUHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_UCharNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.UCharNUHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.UCharNUHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.UCharNUHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< unsigned char > const &":
	return _npstat.UCharNUHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< unsigned char > const &":
	return _npstat.UCharNUHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::NUHistoAxis,std::allocator< npstat::NUHistoAxis > > const &":
	return _npstat.UCharNUHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::NUHistoAxis const &":
	return _npstat.UCharNUHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.UCharNUHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.UCharNUHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.UCharNUHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.UCharNUHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.UCharNUHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.UCharNUHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.UCharNUHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.UCharNUHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.UCharNUHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.UCharNUHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.UCharNUHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.UCharNUHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.UCharNUHistoND_volume(self)

	def integral(self) -> "double":
	return _npstat.UCharNUHistoND_integral(self)

	def clear(self) -> "void":
	return _npstat.UCharNUHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.UCharNUHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.UCharNUHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'UCharNUHistoND') -> "bool":
	return _npstat.UCharNUHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'UCharNUHistoND') -> "bool":
	return _npstat.UCharNUHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'UCharNUHistoND') -> "bool":
	return _npstat.UCharNUHistoND_isSameData(self, arg2)

	def recalculateNFillsFromData(self) -> "void":
	return _npstat.UCharNUHistoND_recalculateNFillsFromData(self)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.UCharNUHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.UCharNUHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< unsigned char,npstat::NUHistoAxis >":
	return _npstat.UCharNUHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.UCharNUHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.UCharNUHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.UCharNUHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.UCharNUHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.UCharNUHistoND_classname)
	else:
	classname = _npstat.UCharNUHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.UCharNUHistoND_version)
	else:
	version = _npstat.UCharNUHistoND_version
	if _newclass:
	read = staticmethod(_npstat.UCharNUHistoND_read)
	else:
	read = _npstat.UCharNUHistoND_read

	def examine(self, *args) -> "unsigned char":
	return _npstat.UCharNUHistoND_examine(self, *args)

	def closestBin(self, *args) -> "unsigned char":
	return _npstat.UCharNUHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.UCharNUHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'unsigned char') -> "void":
	return _npstat.UCharNUHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'unsigned char const') -> "void":
	return _npstat.UCharNUHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'unsigned char const') -> "void":
	return _npstat.UCharNUHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.UCharNUHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_UCharNUHistoND
	__del__ = lambda self: None
	UCharNUHistoND_swigregister = _npstat.UCharNUHistoND_swigregister
	UCharNUHistoND_swigregister(UCharNUHistoND)

	def UCharNUHistoND_classname() -> "char const *":
	return _npstat.UCharNUHistoND_classname()
	UCharNUHistoND_classname = _npstat.UCharNUHistoND_classname

	def UCharNUHistoND_version() -> "unsigned int":
	return _npstat.UCharNUHistoND_version()
	UCharNUHistoND_version = _npstat.UCharNUHistoND_version

	def UCharNUHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< unsigned char,npstat::NUHistoAxis > *":
	return _npstat.UCharNUHistoND_read(id, arg3)
	UCharNUHistoND_read = _npstat.UCharNUHistoND_read

	class FloatNUHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatNUHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatNUHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.FloatNUHistoND_SAMPLE
	SUM = _npstat.FloatNUHistoND_SUM
	AVERAGE = _npstat.FloatNUHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_FloatNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.FloatNUHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.FloatNUHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.FloatNUHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< float > const &":
	return _npstat.FloatNUHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< float > const &":
	return _npstat.FloatNUHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::NUHistoAxis,std::allocator< npstat::NUHistoAxis > > const &":
	return _npstat.FloatNUHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::NUHistoAxis const &":
	return _npstat.FloatNUHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.FloatNUHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.FloatNUHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.FloatNUHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.FloatNUHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.FloatNUHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.FloatNUHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.FloatNUHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.FloatNUHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.FloatNUHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.FloatNUHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.FloatNUHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.FloatNUHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.FloatNUHistoND_volume(self)

	def integral(self) -> "double":
	return _npstat.FloatNUHistoND_integral(self)

	def clear(self) -> "void":
	return _npstat.FloatNUHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.FloatNUHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.FloatNUHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'FloatNUHistoND') -> "bool":
	return _npstat.FloatNUHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'FloatNUHistoND') -> "bool":
	return _npstat.FloatNUHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'FloatNUHistoND') -> "bool":
	return _npstat.FloatNUHistoND_isSameData(self, arg2)

	def recalculateNFillsFromData(self) -> "void":
	return _npstat.FloatNUHistoND_recalculateNFillsFromData(self)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.FloatNUHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.FloatNUHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< float,npstat::NUHistoAxis >":
	return _npstat.FloatNUHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.FloatNUHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.FloatNUHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatNUHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatNUHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatNUHistoND_classname)
	else:
	classname = _npstat.FloatNUHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.FloatNUHistoND_version)
	else:
	version = _npstat.FloatNUHistoND_version
	if _newclass:
	read = staticmethod(_npstat.FloatNUHistoND_read)
	else:
	read = _npstat.FloatNUHistoND_read

	def examine(self, *args) -> "float":
	return _npstat.FloatNUHistoND_examine(self, *args)

	def closestBin(self, *args) -> "float":
	return _npstat.FloatNUHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.FloatNUHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'float') -> "void":
	return _npstat.FloatNUHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'float const') -> "void":
	return _npstat.FloatNUHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'float const') -> "void":
	return _npstat.FloatNUHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.FloatNUHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_FloatNUHistoND
	__del__ = lambda self: None
	FloatNUHistoND_swigregister = _npstat.FloatNUHistoND_swigregister
	FloatNUHistoND_swigregister(FloatNUHistoND)

	def FloatNUHistoND_classname() -> "char const *":
	return _npstat.FloatNUHistoND_classname()
	FloatNUHistoND_classname = _npstat.FloatNUHistoND_classname

	def FloatNUHistoND_version() -> "unsigned int":
	return _npstat.FloatNUHistoND_version()
	FloatNUHistoND_version = _npstat.FloatNUHistoND_version

	def FloatNUHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< float,npstat::NUHistoAxis > *":
	return _npstat.FloatNUHistoND_read(id, arg3)
	FloatNUHistoND_read = _npstat.FloatNUHistoND_read

	class DoubleNUHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleNUHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleNUHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.DoubleNUHistoND_SAMPLE
	SUM = _npstat.DoubleNUHistoND_SUM
	AVERAGE = _npstat.DoubleNUHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_DoubleNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.DoubleNUHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.DoubleNUHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.DoubleNUHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< double > const &":
	return _npstat.DoubleNUHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< double > const &":
	return _npstat.DoubleNUHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::NUHistoAxis,std::allocator< npstat::NUHistoAxis > > const &":
	return _npstat.DoubleNUHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::NUHistoAxis const &":
	return _npstat.DoubleNUHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.DoubleNUHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.DoubleNUHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.DoubleNUHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.DoubleNUHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.DoubleNUHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.DoubleNUHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.DoubleNUHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.DoubleNUHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.DoubleNUHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.DoubleNUHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.DoubleNUHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.DoubleNUHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.DoubleNUHistoND_volume(self)

	def integral(self) -> "double":
	return _npstat.DoubleNUHistoND_integral(self)

	def clear(self) -> "void":
	return _npstat.DoubleNUHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.DoubleNUHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.DoubleNUHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'DoubleNUHistoND') -> "bool":
	return _npstat.DoubleNUHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'DoubleNUHistoND') -> "bool":
	return _npstat.DoubleNUHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'DoubleNUHistoND') -> "bool":
	return _npstat.DoubleNUHistoND_isSameData(self, arg2)

	def recalculateNFillsFromData(self) -> "void":
	return _npstat.DoubleNUHistoND_recalculateNFillsFromData(self)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.DoubleNUHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.DoubleNUHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< double,npstat::NUHistoAxis >":
	return _npstat.DoubleNUHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.DoubleNUHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.DoubleNUHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleNUHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleNUHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleNUHistoND_classname)
	else:
	classname = _npstat.DoubleNUHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleNUHistoND_version)
	else:
	version = _npstat.DoubleNUHistoND_version
	if _newclass:
	read = staticmethod(_npstat.DoubleNUHistoND_read)
	else:
	read = _npstat.DoubleNUHistoND_read

	def examine(self, *args) -> "double":
	return _npstat.DoubleNUHistoND_examine(self, *args)

	def closestBin(self, *args) -> "double":
	return _npstat.DoubleNUHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.DoubleNUHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'double') -> "void":
	return _npstat.DoubleNUHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'double const') -> "void":
	return _npstat.DoubleNUHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'double const') -> "void":
	return _npstat.DoubleNUHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.DoubleNUHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_DoubleNUHistoND
	__del__ = lambda self: None
	DoubleNUHistoND_swigregister = _npstat.DoubleNUHistoND_swigregister
	DoubleNUHistoND_swigregister(DoubleNUHistoND)

	def DoubleNUHistoND_classname() -> "char const *":
	return _npstat.DoubleNUHistoND_classname()
	DoubleNUHistoND_classname = _npstat.DoubleNUHistoND_classname

	def DoubleNUHistoND_version() -> "unsigned int":
	return _npstat.DoubleNUHistoND_version()
	DoubleNUHistoND_version = _npstat.DoubleNUHistoND_version

	def DoubleNUHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< double,npstat::NUHistoAxis > *":
	return _npstat.DoubleNUHistoND_read(id, arg3)
	DoubleNUHistoND_read = _npstat.DoubleNUHistoND_read

	class StatAccNUHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, StatAccNUHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, StatAccNUHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.StatAccNUHistoND_SAMPLE
	SUM = _npstat.StatAccNUHistoND_SUM
	AVERAGE = _npstat.StatAccNUHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_StatAccNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.StatAccNUHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.StatAccNUHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.StatAccNUHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::StatAccumulator > const &":
	return _npstat.StatAccNUHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::StatAccumulator > const &":
	return _npstat.StatAccNUHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::NUHistoAxis,std::allocator< npstat::NUHistoAxis > > const &":
	return _npstat.StatAccNUHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::NUHistoAxis const &":
	return _npstat.StatAccNUHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.StatAccNUHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.StatAccNUHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.StatAccNUHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.StatAccNUHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.StatAccNUHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.StatAccNUHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.StatAccNUHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.StatAccNUHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.StatAccNUHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.StatAccNUHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.StatAccNUHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.StatAccNUHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.StatAccNUHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.StatAccNUHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.StatAccNUHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.StatAccNUHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'StatAccNUHistoND') -> "bool":
	return _npstat.StatAccNUHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'StatAccNUHistoND') -> "bool":
	return _npstat.StatAccNUHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'StatAccNUHistoND') -> "bool":
	return _npstat.StatAccNUHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.StatAccNUHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.StatAccNUHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::StatAccumulator,npstat::NUHistoAxis >":
	return _npstat.StatAccNUHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.StatAccNUHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.StatAccNUHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.StatAccNUHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.StatAccNUHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.StatAccNUHistoND_classname)
	else:
	classname = _npstat.StatAccNUHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.StatAccNUHistoND_version)
	else:
	version = _npstat.StatAccNUHistoND_version
	if _newclass:
	read = staticmethod(_npstat.StatAccNUHistoND_read)
	else:
	read = _npstat.StatAccNUHistoND_read

	def examine(self, *args) -> "npstat::StatAccumulator":
	return _npstat.StatAccNUHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::StatAccumulator":
	return _npstat.StatAccNUHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.StatAccNUHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'StatAccumulator') -> "void":
	return _npstat.StatAccNUHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'StatAccumulator') -> "void":
	return _npstat.StatAccNUHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'StatAccumulator') -> "void":
	return _npstat.StatAccNUHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.StatAccNUHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_StatAccNUHistoND
	__del__ = lambda self: None
	StatAccNUHistoND_swigregister = _npstat.StatAccNUHistoND_swigregister
	StatAccNUHistoND_swigregister(StatAccNUHistoND)

	def StatAccNUHistoND_classname() -> "char const *":
	return _npstat.StatAccNUHistoND_classname()
	StatAccNUHistoND_classname = _npstat.StatAccNUHistoND_classname

	def StatAccNUHistoND_version() -> "unsigned int":
	return _npstat.StatAccNUHistoND_version()
	StatAccNUHistoND_version = _npstat.StatAccNUHistoND_version

	def StatAccNUHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::StatAccumulator,npstat::NUHistoAxis > *":
	return _npstat.StatAccNUHistoND_read(id, arg3)
	StatAccNUHistoND_read = _npstat.StatAccNUHistoND_read

	class WStatAccNUHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, WStatAccNUHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, WStatAccNUHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.WStatAccNUHistoND_SAMPLE
	SUM = _npstat.WStatAccNUHistoND_SUM
	AVERAGE = _npstat.WStatAccNUHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_WStatAccNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.WStatAccNUHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.WStatAccNUHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.WStatAccNUHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::WeightedStatAccumulator > const &":
	return _npstat.WStatAccNUHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::WeightedStatAccumulator > const &":
	return _npstat.WStatAccNUHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::NUHistoAxis,std::allocator< npstat::NUHistoAxis > > const &":
	return _npstat.WStatAccNUHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::NUHistoAxis const &":
	return _npstat.WStatAccNUHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.WStatAccNUHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.WStatAccNUHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.WStatAccNUHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.WStatAccNUHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.WStatAccNUHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.WStatAccNUHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.WStatAccNUHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.WStatAccNUHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.WStatAccNUHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.WStatAccNUHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.WStatAccNUHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.WStatAccNUHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.WStatAccNUHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.WStatAccNUHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.WStatAccNUHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.WStatAccNUHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'WStatAccNUHistoND') -> "bool":
	return _npstat.WStatAccNUHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'WStatAccNUHistoND') -> "bool":
	return _npstat.WStatAccNUHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'WStatAccNUHistoND') -> "bool":
	return _npstat.WStatAccNUHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.WStatAccNUHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.WStatAccNUHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::WeightedStatAccumulator,npstat::NUHistoAxis >":
	return _npstat.WStatAccNUHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.WStatAccNUHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.WStatAccNUHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.WStatAccNUHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.WStatAccNUHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.WStatAccNUHistoND_classname)
	else:
	classname = _npstat.WStatAccNUHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.WStatAccNUHistoND_version)
	else:
	version = _npstat.WStatAccNUHistoND_version
	if _newclass:
	read = staticmethod(_npstat.WStatAccNUHistoND_read)
	else:
	read = _npstat.WStatAccNUHistoND_read

	def examine(self, *args) -> "npstat::WeightedStatAccumulator":
	return _npstat.WStatAccNUHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::WeightedStatAccumulator":
	return _npstat.WStatAccNUHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.WStatAccNUHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'WeightedStatAccumulator') -> "void":
	return _npstat.WStatAccNUHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'WeightedStatAccumulator') -> "void":
	return _npstat.WStatAccNUHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'WeightedStatAccumulator') -> "void":
	return _npstat.WStatAccNUHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.WStatAccNUHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_WStatAccNUHistoND
	__del__ = lambda self: None
	WStatAccNUHistoND_swigregister = _npstat.WStatAccNUHistoND_swigregister
	WStatAccNUHistoND_swigregister(WStatAccNUHistoND)

	def WStatAccNUHistoND_classname() -> "char const *":
	return _npstat.WStatAccNUHistoND_classname()
	WStatAccNUHistoND_classname = _npstat.WStatAccNUHistoND_classname

	def WStatAccNUHistoND_version() -> "unsigned int":
	return _npstat.WStatAccNUHistoND_version()
	WStatAccNUHistoND_version = _npstat.WStatAccNUHistoND_version

	def WStatAccNUHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::WeightedStatAccumulator,npstat::NUHistoAxis > *":
	return _npstat.WStatAccNUHistoND_read(id, arg3)
	WStatAccNUHistoND_read = _npstat.WStatAccNUHistoND_read

	class BinSummaryNUHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, BinSummaryNUHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, BinSummaryNUHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.BinSummaryNUHistoND_SAMPLE
	SUM = _npstat.BinSummaryNUHistoND_SUM
	AVERAGE = _npstat.BinSummaryNUHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_BinSummaryNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.BinSummaryNUHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.BinSummaryNUHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.BinSummaryNUHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::BinSummary > const &":
	return _npstat.BinSummaryNUHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::BinSummary > const &":
	return _npstat.BinSummaryNUHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::NUHistoAxis,std::allocator< npstat::NUHistoAxis > > const &":
	return _npstat.BinSummaryNUHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::NUHistoAxis const &":
	return _npstat.BinSummaryNUHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.BinSummaryNUHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.BinSummaryNUHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.BinSummaryNUHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.BinSummaryNUHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.BinSummaryNUHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.BinSummaryNUHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.BinSummaryNUHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.BinSummaryNUHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.BinSummaryNUHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.BinSummaryNUHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.BinSummaryNUHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.BinSummaryNUHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.BinSummaryNUHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.BinSummaryNUHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.BinSummaryNUHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.BinSummaryNUHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'BinSummaryNUHistoND') -> "bool":
	return _npstat.BinSummaryNUHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'BinSummaryNUHistoND') -> "bool":
	return _npstat.BinSummaryNUHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'BinSummaryNUHistoND') -> "bool":
	return _npstat.BinSummaryNUHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.BinSummaryNUHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.BinSummaryNUHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::BinSummary,npstat::NUHistoAxis >":
	return _npstat.BinSummaryNUHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.BinSummaryNUHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.BinSummaryNUHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.BinSummaryNUHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.BinSummaryNUHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.BinSummaryNUHistoND_classname)
	else:
	classname = _npstat.BinSummaryNUHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.BinSummaryNUHistoND_version)
	else:
	version = _npstat.BinSummaryNUHistoND_version
	if _newclass:
	read = staticmethod(_npstat.BinSummaryNUHistoND_read)
	else:
	read = _npstat.BinSummaryNUHistoND_read

	def examine(self, *args) -> "npstat::BinSummary":
	return _npstat.BinSummaryNUHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::BinSummary":
	return _npstat.BinSummaryNUHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.BinSummaryNUHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'BinSummary') -> "void":
	return _npstat.BinSummaryNUHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'BinSummary') -> "void":
	return _npstat.BinSummaryNUHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'BinSummary') -> "void":
	return _npstat.BinSummaryNUHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.BinSummaryNUHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_BinSummaryNUHistoND
	__del__ = lambda self: None
	BinSummaryNUHistoND_swigregister = _npstat.BinSummaryNUHistoND_swigregister
	BinSummaryNUHistoND_swigregister(BinSummaryNUHistoND)

	def BinSummaryNUHistoND_classname() -> "char const *":
	return _npstat.BinSummaryNUHistoND_classname()
	BinSummaryNUHistoND_classname = _npstat.BinSummaryNUHistoND_classname

	def BinSummaryNUHistoND_version() -> "unsigned int":
	return _npstat.BinSummaryNUHistoND_version()
	BinSummaryNUHistoND_version = _npstat.BinSummaryNUHistoND_version

	def BinSummaryNUHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::BinSummary,npstat::NUHistoAxis > *":
	return _npstat.BinSummaryNUHistoND_read(id, arg3)
	BinSummaryNUHistoND_read = _npstat.BinSummaryNUHistoND_read

	class FSampleAccNUHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FSampleAccNUHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FSampleAccNUHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.FSampleAccNUHistoND_SAMPLE
	SUM = _npstat.FSampleAccNUHistoND_SUM
	AVERAGE = _npstat.FSampleAccNUHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_FSampleAccNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.FSampleAccNUHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.FSampleAccNUHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.FSampleAccNUHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::SampleAccumulator< float,long double > > const &":
	return _npstat.FSampleAccNUHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::SampleAccumulator< float,long double > > const &":
	return _npstat.FSampleAccNUHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::NUHistoAxis,std::allocator< npstat::NUHistoAxis > > const &":
	return _npstat.FSampleAccNUHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::NUHistoAxis const &":
	return _npstat.FSampleAccNUHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.FSampleAccNUHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.FSampleAccNUHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.FSampleAccNUHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.FSampleAccNUHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.FSampleAccNUHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.FSampleAccNUHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.FSampleAccNUHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.FSampleAccNUHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.FSampleAccNUHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.FSampleAccNUHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.FSampleAccNUHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.FSampleAccNUHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.FSampleAccNUHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.FSampleAccNUHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.FSampleAccNUHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.FSampleAccNUHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'FSampleAccNUHistoND') -> "bool":
	return _npstat.FSampleAccNUHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'FSampleAccNUHistoND') -> "bool":
	return _npstat.FSampleAccNUHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'FSampleAccNUHistoND') -> "bool":
	return _npstat.FSampleAccNUHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.FSampleAccNUHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.FSampleAccNUHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::FloatSampleAccumulator,npstat::NUHistoAxis >":
	return _npstat.FSampleAccNUHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.FSampleAccNUHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.FSampleAccNUHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.FSampleAccNUHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FSampleAccNUHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FSampleAccNUHistoND_classname)
	else:
	classname = _npstat.FSampleAccNUHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.FSampleAccNUHistoND_version)
	else:
	version = _npstat.FSampleAccNUHistoND_version
	if _newclass:
	read = staticmethod(_npstat.FSampleAccNUHistoND_read)
	else:
	read = _npstat.FSampleAccNUHistoND_read

	def examine(self, *args) -> "npstat::SampleAccumulator< float,long double >":
	return _npstat.FSampleAccNUHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::SampleAccumulator< float,long double >":
	return _npstat.FSampleAccNUHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.FSampleAccNUHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'FloatSampleAccumulator') -> "void":
	return _npstat.FSampleAccNUHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'FloatSampleAccumulator') -> "void":
	return _npstat.FSampleAccNUHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'FloatSampleAccumulator') -> "void":
	return _npstat.FSampleAccNUHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.FSampleAccNUHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_FSampleAccNUHistoND
	__del__ = lambda self: None
	FSampleAccNUHistoND_swigregister = _npstat.FSampleAccNUHistoND_swigregister
	FSampleAccNUHistoND_swigregister(FSampleAccNUHistoND)

	def FSampleAccNUHistoND_classname() -> "char const *":
	return _npstat.FSampleAccNUHistoND_classname()
	FSampleAccNUHistoND_classname = _npstat.FSampleAccNUHistoND_classname

	def FSampleAccNUHistoND_version() -> "unsigned int":
	return _npstat.FSampleAccNUHistoND_version()
	FSampleAccNUHistoND_version = _npstat.FSampleAccNUHistoND_version

	def FSampleAccNUHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::FloatSampleAccumulator,npstat::NUHistoAxis > *":
	return _npstat.FSampleAccNUHistoND_read(id, arg3)
	FSampleAccNUHistoND_read = _npstat.FSampleAccNUHistoND_read

	class DSampleAccNUHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DSampleAccNUHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DSampleAccNUHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.DSampleAccNUHistoND_SAMPLE
	SUM = _npstat.DSampleAccNUHistoND_SUM
	AVERAGE = _npstat.DSampleAccNUHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_DSampleAccNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.DSampleAccNUHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.DSampleAccNUHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.DSampleAccNUHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::SampleAccumulator< double,long double > > const &":
	return _npstat.DSampleAccNUHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::SampleAccumulator< double,long double > > const &":
	return _npstat.DSampleAccNUHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::NUHistoAxis,std::allocator< npstat::NUHistoAxis > > const &":
	return _npstat.DSampleAccNUHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::NUHistoAxis const &":
	return _npstat.DSampleAccNUHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.DSampleAccNUHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.DSampleAccNUHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.DSampleAccNUHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.DSampleAccNUHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.DSampleAccNUHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.DSampleAccNUHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.DSampleAccNUHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.DSampleAccNUHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.DSampleAccNUHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.DSampleAccNUHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.DSampleAccNUHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.DSampleAccNUHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.DSampleAccNUHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.DSampleAccNUHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.DSampleAccNUHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.DSampleAccNUHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'DSampleAccNUHistoND') -> "bool":
	return _npstat.DSampleAccNUHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'DSampleAccNUHistoND') -> "bool":
	return _npstat.DSampleAccNUHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'DSampleAccNUHistoND') -> "bool":
	return _npstat.DSampleAccNUHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.DSampleAccNUHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.DSampleAccNUHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::NUHistoAxis >":
	return _npstat.DSampleAccNUHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.DSampleAccNUHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.DSampleAccNUHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.DSampleAccNUHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DSampleAccNUHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DSampleAccNUHistoND_classname)
	else:
	classname = _npstat.DSampleAccNUHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.DSampleAccNUHistoND_version)
	else:
	version = _npstat.DSampleAccNUHistoND_version
	if _newclass:
	read = staticmethod(_npstat.DSampleAccNUHistoND_read)
	else:
	read = _npstat.DSampleAccNUHistoND_read

	def examine(self, *args) -> "npstat::SampleAccumulator< double,long double >":
	return _npstat.DSampleAccNUHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::SampleAccumulator< double,long double >":
	return _npstat.DSampleAccNUHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.DSampleAccNUHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'DoubleSampleAccumulator') -> "void":
	return _npstat.DSampleAccNUHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'DoubleSampleAccumulator') -> "void":
	return _npstat.DSampleAccNUHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'DoubleSampleAccumulator') -> "void":
	return _npstat.DSampleAccNUHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.DSampleAccNUHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_DSampleAccNUHistoND
	__del__ = lambda self: None
	DSampleAccNUHistoND_swigregister = _npstat.DSampleAccNUHistoND_swigregister
	DSampleAccNUHistoND_swigregister(DSampleAccNUHistoND)

	def DSampleAccNUHistoND_classname() -> "char const *":
	return _npstat.DSampleAccNUHistoND_classname()
	DSampleAccNUHistoND_classname = _npstat.DSampleAccNUHistoND_classname

	def DSampleAccNUHistoND_version() -> "unsigned int":
	return _npstat.DSampleAccNUHistoND_version()
	DSampleAccNUHistoND_version = _npstat.DSampleAccNUHistoND_version

	def DSampleAccNUHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::NUHistoAxis > *":
	return _npstat.DSampleAccNUHistoND_read(id, arg3)
	DSampleAccNUHistoND_read = _npstat.DSampleAccNUHistoND_read

	class DWSampleAccNUHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DWSampleAccNUHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DWSampleAccNUHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.DWSampleAccNUHistoND_SAMPLE
	SUM = _npstat.DWSampleAccNUHistoND_SUM
	AVERAGE = _npstat.DWSampleAccNUHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_DWSampleAccNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.DWSampleAccNUHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.DWSampleAccNUHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.DWSampleAccNUHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::WeightedSampleAccumulator< double,long double > > const &":
	return _npstat.DWSampleAccNUHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::WeightedSampleAccumulator< double,long double > > const &":
	return _npstat.DWSampleAccNUHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::NUHistoAxis,std::allocator< npstat::NUHistoAxis > > const &":
	return _npstat.DWSampleAccNUHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::NUHistoAxis const &":
	return _npstat.DWSampleAccNUHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.DWSampleAccNUHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.DWSampleAccNUHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.DWSampleAccNUHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.DWSampleAccNUHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.DWSampleAccNUHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.DWSampleAccNUHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.DWSampleAccNUHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.DWSampleAccNUHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.DWSampleAccNUHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.DWSampleAccNUHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.DWSampleAccNUHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.DWSampleAccNUHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.DWSampleAccNUHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.DWSampleAccNUHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.DWSampleAccNUHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.DWSampleAccNUHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'DWSampleAccNUHistoND') -> "bool":
	return _npstat.DWSampleAccNUHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'DWSampleAccNUHistoND') -> "bool":
	return _npstat.DWSampleAccNUHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'DWSampleAccNUHistoND') -> "bool":
	return _npstat.DWSampleAccNUHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.DWSampleAccNUHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.DWSampleAccNUHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::NUHistoAxis >":
	return _npstat.DWSampleAccNUHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.DWSampleAccNUHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.DWSampleAccNUHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.DWSampleAccNUHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DWSampleAccNUHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DWSampleAccNUHistoND_classname)
	else:
	classname = _npstat.DWSampleAccNUHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.DWSampleAccNUHistoND_version)
	else:
	version = _npstat.DWSampleAccNUHistoND_version
	if _newclass:
	read = staticmethod(_npstat.DWSampleAccNUHistoND_read)
	else:
	read = _npstat.DWSampleAccNUHistoND_read

	def examine(self, *args) -> "npstat::WeightedSampleAccumulator< double,long double >":
	return _npstat.DWSampleAccNUHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::WeightedSampleAccumulator< double,long double >":
	return _npstat.DWSampleAccNUHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.DWSampleAccNUHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'DoubleWeightedSampleAccumulator') -> "void":
	return _npstat.DWSampleAccNUHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'DoubleWeightedSampleAccumulator') -> "void":
	return _npstat.DWSampleAccNUHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'DoubleWeightedSampleAccumulator') -> "void":
	return _npstat.DWSampleAccNUHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.DWSampleAccNUHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_DWSampleAccNUHistoND
	__del__ = lambda self: None
	DWSampleAccNUHistoND_swigregister = _npstat.DWSampleAccNUHistoND_swigregister
	DWSampleAccNUHistoND_swigregister(DWSampleAccNUHistoND)

	def DWSampleAccNUHistoND_classname() -> "char const *":
	return _npstat.DWSampleAccNUHistoND_classname()
	DWSampleAccNUHistoND_classname = _npstat.DWSampleAccNUHistoND_classname

	def DWSampleAccNUHistoND_version() -> "unsigned int":
	return _npstat.DWSampleAccNUHistoND_version()
	DWSampleAccNUHistoND_version = _npstat.DWSampleAccNUHistoND_version

	def DWSampleAccNUHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::NUHistoAxis > *":
	return _npstat.DWSampleAccNUHistoND_read(id, arg3)
	DWSampleAccNUHistoND_read = _npstat.DWSampleAccNUHistoND_read

	class IntDAHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntDAHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntDAHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.IntDAHistoND_SAMPLE
	SUM = _npstat.IntDAHistoND_SUM
	AVERAGE = _npstat.IntDAHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_IntDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.IntDAHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.IntDAHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.IntDAHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< int > const &":
	return _npstat.IntDAHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< int > const &":
	return _npstat.IntDAHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::DualHistoAxis,std::allocator< npstat::DualHistoAxis > > const &":
	return _npstat.IntDAHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::DualHistoAxis const &":
	return _npstat.IntDAHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.IntDAHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.IntDAHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.IntDAHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.IntDAHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.IntDAHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.IntDAHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.IntDAHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.IntDAHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.IntDAHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.IntDAHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.IntDAHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.IntDAHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.IntDAHistoND_volume(self)

	def integral(self) -> "double":
	return _npstat.IntDAHistoND_integral(self)

	def clear(self) -> "void":
	return _npstat.IntDAHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.IntDAHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.IntDAHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'IntDAHistoND') -> "bool":
	return _npstat.IntDAHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'IntDAHistoND') -> "bool":
	return _npstat.IntDAHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'IntDAHistoND') -> "bool":
	return _npstat.IntDAHistoND_isSameData(self, arg2)

	def recalculateNFillsFromData(self) -> "void":
	return _npstat.IntDAHistoND_recalculateNFillsFromData(self)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.IntDAHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.IntDAHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< int,npstat::DualHistoAxis >":
	return _npstat.IntDAHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.IntDAHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.IntDAHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.IntDAHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.IntDAHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.IntDAHistoND_classname)
	else:
	classname = _npstat.IntDAHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.IntDAHistoND_version)
	else:
	version = _npstat.IntDAHistoND_version
	if _newclass:
	read = staticmethod(_npstat.IntDAHistoND_read)
	else:
	read = _npstat.IntDAHistoND_read

	def examine(self, *args) -> "int":
	return _npstat.IntDAHistoND_examine(self, *args)

	def closestBin(self, *args) -> "int":
	return _npstat.IntDAHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.IntDAHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'int') -> "void":
	return _npstat.IntDAHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'int const') -> "void":
	return _npstat.IntDAHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'int const') -> "void":
	return _npstat.IntDAHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.IntDAHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_IntDAHistoND
	__del__ = lambda self: None
	IntDAHistoND_swigregister = _npstat.IntDAHistoND_swigregister
	IntDAHistoND_swigregister(IntDAHistoND)

	def IntDAHistoND_classname() -> "char const *":
	return _npstat.IntDAHistoND_classname()
	IntDAHistoND_classname = _npstat.IntDAHistoND_classname

	def IntDAHistoND_version() -> "unsigned int":
	return _npstat.IntDAHistoND_version()
	IntDAHistoND_version = _npstat.IntDAHistoND_version

	def IntDAHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< int,npstat::DualHistoAxis > *":
	return _npstat.IntDAHistoND_read(id, arg3)
	IntDAHistoND_read = _npstat.IntDAHistoND_read

	class LLongDAHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongDAHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongDAHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.LLongDAHistoND_SAMPLE
	SUM = _npstat.LLongDAHistoND_SUM
	AVERAGE = _npstat.LLongDAHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_LLongDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.LLongDAHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.LLongDAHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.LLongDAHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< long long > const &":
	return _npstat.LLongDAHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< long long > const &":
	return _npstat.LLongDAHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::DualHistoAxis,std::allocator< npstat::DualHistoAxis > > const &":
	return _npstat.LLongDAHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::DualHistoAxis const &":
	return _npstat.LLongDAHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.LLongDAHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.LLongDAHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.LLongDAHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.LLongDAHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.LLongDAHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.LLongDAHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.LLongDAHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.LLongDAHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.LLongDAHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.LLongDAHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.LLongDAHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.LLongDAHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.LLongDAHistoND_volume(self)

	def integral(self) -> "double":
	return _npstat.LLongDAHistoND_integral(self)

	def clear(self) -> "void":
	return _npstat.LLongDAHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.LLongDAHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.LLongDAHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'LLongDAHistoND') -> "bool":
	return _npstat.LLongDAHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'LLongDAHistoND') -> "bool":
	return _npstat.LLongDAHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'LLongDAHistoND') -> "bool":
	return _npstat.LLongDAHistoND_isSameData(self, arg2)

	def recalculateNFillsFromData(self) -> "void":
	return _npstat.LLongDAHistoND_recalculateNFillsFromData(self)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.LLongDAHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.LLongDAHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< long long,npstat::DualHistoAxis >":
	return _npstat.LLongDAHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.LLongDAHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.LLongDAHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.LLongDAHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.LLongDAHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.LLongDAHistoND_classname)
	else:
	classname = _npstat.LLongDAHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.LLongDAHistoND_version)
	else:
	version = _npstat.LLongDAHistoND_version
	if _newclass:
	read = staticmethod(_npstat.LLongDAHistoND_read)
	else:
	read = _npstat.LLongDAHistoND_read

	def examine(self, *args) -> "long long":
	return _npstat.LLongDAHistoND_examine(self, *args)

	def closestBin(self, *args) -> "long long":
	return _npstat.LLongDAHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.LLongDAHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'long long') -> "void":
	return _npstat.LLongDAHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'long long const') -> "void":
	return _npstat.LLongDAHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'long long const') -> "void":
	return _npstat.LLongDAHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.LLongDAHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_LLongDAHistoND
	__del__ = lambda self: None
	LLongDAHistoND_swigregister = _npstat.LLongDAHistoND_swigregister
	LLongDAHistoND_swigregister(LLongDAHistoND)

	def LLongDAHistoND_classname() -> "char const *":
	return _npstat.LLongDAHistoND_classname()
	LLongDAHistoND_classname = _npstat.LLongDAHistoND_classname

	def LLongDAHistoND_version() -> "unsigned int":
	return _npstat.LLongDAHistoND_version()
	LLongDAHistoND_version = _npstat.LLongDAHistoND_version

	def LLongDAHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< long long,npstat::DualHistoAxis > *":
	return _npstat.LLongDAHistoND_read(id, arg3)
	LLongDAHistoND_read = _npstat.LLongDAHistoND_read

	class UCharDAHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharDAHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharDAHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.UCharDAHistoND_SAMPLE
	SUM = _npstat.UCharDAHistoND_SUM
	AVERAGE = _npstat.UCharDAHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_UCharDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.UCharDAHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.UCharDAHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.UCharDAHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< unsigned char > const &":
	return _npstat.UCharDAHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< unsigned char > const &":
	return _npstat.UCharDAHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::DualHistoAxis,std::allocator< npstat::DualHistoAxis > > const &":
	return _npstat.UCharDAHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::DualHistoAxis const &":
	return _npstat.UCharDAHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.UCharDAHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.UCharDAHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.UCharDAHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.UCharDAHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.UCharDAHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.UCharDAHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.UCharDAHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.UCharDAHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.UCharDAHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.UCharDAHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.UCharDAHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.UCharDAHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.UCharDAHistoND_volume(self)

	def integral(self) -> "double":
	return _npstat.UCharDAHistoND_integral(self)

	def clear(self) -> "void":
	return _npstat.UCharDAHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.UCharDAHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.UCharDAHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'UCharDAHistoND') -> "bool":
	return _npstat.UCharDAHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'UCharDAHistoND') -> "bool":
	return _npstat.UCharDAHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'UCharDAHistoND') -> "bool":
	return _npstat.UCharDAHistoND_isSameData(self, arg2)

	def recalculateNFillsFromData(self) -> "void":
	return _npstat.UCharDAHistoND_recalculateNFillsFromData(self)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.UCharDAHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.UCharDAHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< unsigned char,npstat::DualHistoAxis >":
	return _npstat.UCharDAHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.UCharDAHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.UCharDAHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.UCharDAHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.UCharDAHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.UCharDAHistoND_classname)
	else:
	classname = _npstat.UCharDAHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.UCharDAHistoND_version)
	else:
	version = _npstat.UCharDAHistoND_version
	if _newclass:
	read = staticmethod(_npstat.UCharDAHistoND_read)
	else:
	read = _npstat.UCharDAHistoND_read

	def examine(self, *args) -> "unsigned char":
	return _npstat.UCharDAHistoND_examine(self, *args)

	def closestBin(self, *args) -> "unsigned char":
	return _npstat.UCharDAHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.UCharDAHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'unsigned char') -> "void":
	return _npstat.UCharDAHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'unsigned char const') -> "void":
	return _npstat.UCharDAHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'unsigned char const') -> "void":
	return _npstat.UCharDAHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.UCharDAHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_UCharDAHistoND
	__del__ = lambda self: None
	UCharDAHistoND_swigregister = _npstat.UCharDAHistoND_swigregister
	UCharDAHistoND_swigregister(UCharDAHistoND)

	def UCharDAHistoND_classname() -> "char const *":
	return _npstat.UCharDAHistoND_classname()
	UCharDAHistoND_classname = _npstat.UCharDAHistoND_classname

	def UCharDAHistoND_version() -> "unsigned int":
	return _npstat.UCharDAHistoND_version()
	UCharDAHistoND_version = _npstat.UCharDAHistoND_version

	def UCharDAHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< unsigned char,npstat::DualHistoAxis > *":
	return _npstat.UCharDAHistoND_read(id, arg3)
	UCharDAHistoND_read = _npstat.UCharDAHistoND_read

	class FloatDAHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatDAHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatDAHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.FloatDAHistoND_SAMPLE
	SUM = _npstat.FloatDAHistoND_SUM
	AVERAGE = _npstat.FloatDAHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_FloatDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.FloatDAHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.FloatDAHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.FloatDAHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< float > const &":
	return _npstat.FloatDAHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< float > const &":
	return _npstat.FloatDAHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::DualHistoAxis,std::allocator< npstat::DualHistoAxis > > const &":
	return _npstat.FloatDAHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::DualHistoAxis const &":
	return _npstat.FloatDAHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.FloatDAHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.FloatDAHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.FloatDAHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.FloatDAHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.FloatDAHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.FloatDAHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.FloatDAHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.FloatDAHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.FloatDAHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.FloatDAHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.FloatDAHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.FloatDAHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.FloatDAHistoND_volume(self)

	def integral(self) -> "double":
	return _npstat.FloatDAHistoND_integral(self)

	def clear(self) -> "void":
	return _npstat.FloatDAHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.FloatDAHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.FloatDAHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'FloatDAHistoND') -> "bool":
	return _npstat.FloatDAHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'FloatDAHistoND') -> "bool":
	return _npstat.FloatDAHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'FloatDAHistoND') -> "bool":
	return _npstat.FloatDAHistoND_isSameData(self, arg2)

	def recalculateNFillsFromData(self) -> "void":
	return _npstat.FloatDAHistoND_recalculateNFillsFromData(self)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.FloatDAHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.FloatDAHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< float,npstat::DualHistoAxis >":
	return _npstat.FloatDAHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.FloatDAHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.FloatDAHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatDAHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatDAHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatDAHistoND_classname)
	else:
	classname = _npstat.FloatDAHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.FloatDAHistoND_version)
	else:
	version = _npstat.FloatDAHistoND_version
	if _newclass:
	read = staticmethod(_npstat.FloatDAHistoND_read)
	else:
	read = _npstat.FloatDAHistoND_read

	def examine(self, *args) -> "float":
	return _npstat.FloatDAHistoND_examine(self, *args)

	def closestBin(self, *args) -> "float":
	return _npstat.FloatDAHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.FloatDAHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'float') -> "void":
	return _npstat.FloatDAHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'float const') -> "void":
	return _npstat.FloatDAHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'float const') -> "void":
	return _npstat.FloatDAHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.FloatDAHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_FloatDAHistoND
	__del__ = lambda self: None
	FloatDAHistoND_swigregister = _npstat.FloatDAHistoND_swigregister
	FloatDAHistoND_swigregister(FloatDAHistoND)

	def FloatDAHistoND_classname() -> "char const *":
	return _npstat.FloatDAHistoND_classname()
	FloatDAHistoND_classname = _npstat.FloatDAHistoND_classname

	def FloatDAHistoND_version() -> "unsigned int":
	return _npstat.FloatDAHistoND_version()
	FloatDAHistoND_version = _npstat.FloatDAHistoND_version

	def FloatDAHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< float,npstat::DualHistoAxis > *":
	return _npstat.FloatDAHistoND_read(id, arg3)
	FloatDAHistoND_read = _npstat.FloatDAHistoND_read

	class DoubleDAHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleDAHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleDAHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.DoubleDAHistoND_SAMPLE
	SUM = _npstat.DoubleDAHistoND_SUM
	AVERAGE = _npstat.DoubleDAHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_DoubleDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.DoubleDAHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.DoubleDAHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.DoubleDAHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< double > const &":
	return _npstat.DoubleDAHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< double > const &":
	return _npstat.DoubleDAHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::DualHistoAxis,std::allocator< npstat::DualHistoAxis > > const &":
	return _npstat.DoubleDAHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::DualHistoAxis const &":
	return _npstat.DoubleDAHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.DoubleDAHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.DoubleDAHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.DoubleDAHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.DoubleDAHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.DoubleDAHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.DoubleDAHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.DoubleDAHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.DoubleDAHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.DoubleDAHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.DoubleDAHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.DoubleDAHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.DoubleDAHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.DoubleDAHistoND_volume(self)

	def integral(self) -> "double":
	return _npstat.DoubleDAHistoND_integral(self)

	def clear(self) -> "void":
	return _npstat.DoubleDAHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.DoubleDAHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.DoubleDAHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'DoubleDAHistoND') -> "bool":
	return _npstat.DoubleDAHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'DoubleDAHistoND') -> "bool":
	return _npstat.DoubleDAHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'DoubleDAHistoND') -> "bool":
	return _npstat.DoubleDAHistoND_isSameData(self, arg2)

	def recalculateNFillsFromData(self) -> "void":
	return _npstat.DoubleDAHistoND_recalculateNFillsFromData(self)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.DoubleDAHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.DoubleDAHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< double,npstat::DualHistoAxis >":
	return _npstat.DoubleDAHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.DoubleDAHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.DoubleDAHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleDAHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleDAHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleDAHistoND_classname)
	else:
	classname = _npstat.DoubleDAHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleDAHistoND_version)
	else:
	version = _npstat.DoubleDAHistoND_version
	if _newclass:
	read = staticmethod(_npstat.DoubleDAHistoND_read)
	else:
	read = _npstat.DoubleDAHistoND_read

	def examine(self, *args) -> "double":
	return _npstat.DoubleDAHistoND_examine(self, *args)

	def closestBin(self, *args) -> "double":
	return _npstat.DoubleDAHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.DoubleDAHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'double') -> "void":
	return _npstat.DoubleDAHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'double const') -> "void":
	return _npstat.DoubleDAHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'double const') -> "void":
	return _npstat.DoubleDAHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.DoubleDAHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_DoubleDAHistoND
	__del__ = lambda self: None
	DoubleDAHistoND_swigregister = _npstat.DoubleDAHistoND_swigregister
	DoubleDAHistoND_swigregister(DoubleDAHistoND)

	def DoubleDAHistoND_classname() -> "char const *":
	return _npstat.DoubleDAHistoND_classname()
	DoubleDAHistoND_classname = _npstat.DoubleDAHistoND_classname

	def DoubleDAHistoND_version() -> "unsigned int":
	return _npstat.DoubleDAHistoND_version()
	DoubleDAHistoND_version = _npstat.DoubleDAHistoND_version

	def DoubleDAHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< double,npstat::DualHistoAxis > *":
	return _npstat.DoubleDAHistoND_read(id, arg3)
	DoubleDAHistoND_read = _npstat.DoubleDAHistoND_read

	class StatAccDAHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, StatAccDAHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, StatAccDAHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.StatAccDAHistoND_SAMPLE
	SUM = _npstat.StatAccDAHistoND_SUM
	AVERAGE = _npstat.StatAccDAHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_StatAccDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.StatAccDAHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.StatAccDAHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.StatAccDAHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::StatAccumulator > const &":
	return _npstat.StatAccDAHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::StatAccumulator > const &":
	return _npstat.StatAccDAHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::DualHistoAxis,std::allocator< npstat::DualHistoAxis > > const &":
	return _npstat.StatAccDAHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::DualHistoAxis const &":
	return _npstat.StatAccDAHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.StatAccDAHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.StatAccDAHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.StatAccDAHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.StatAccDAHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.StatAccDAHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.StatAccDAHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.StatAccDAHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.StatAccDAHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.StatAccDAHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.StatAccDAHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.StatAccDAHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.StatAccDAHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.StatAccDAHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.StatAccDAHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.StatAccDAHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.StatAccDAHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'StatAccDAHistoND') -> "bool":
	return _npstat.StatAccDAHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'StatAccDAHistoND') -> "bool":
	return _npstat.StatAccDAHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'StatAccDAHistoND') -> "bool":
	return _npstat.StatAccDAHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.StatAccDAHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.StatAccDAHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::StatAccumulator,npstat::DualHistoAxis >":
	return _npstat.StatAccDAHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.StatAccDAHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.StatAccDAHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.StatAccDAHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.StatAccDAHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.StatAccDAHistoND_classname)
	else:
	classname = _npstat.StatAccDAHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.StatAccDAHistoND_version)
	else:
	version = _npstat.StatAccDAHistoND_version
	if _newclass:
	read = staticmethod(_npstat.StatAccDAHistoND_read)
	else:
	read = _npstat.StatAccDAHistoND_read

	def examine(self, *args) -> "npstat::StatAccumulator":
	return _npstat.StatAccDAHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::StatAccumulator":
	return _npstat.StatAccDAHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.StatAccDAHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'StatAccumulator') -> "void":
	return _npstat.StatAccDAHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'StatAccumulator') -> "void":
	return _npstat.StatAccDAHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'StatAccumulator') -> "void":
	return _npstat.StatAccDAHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.StatAccDAHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_StatAccDAHistoND
	__del__ = lambda self: None
	StatAccDAHistoND_swigregister = _npstat.StatAccDAHistoND_swigregister
	StatAccDAHistoND_swigregister(StatAccDAHistoND)

	def StatAccDAHistoND_classname() -> "char const *":
	return _npstat.StatAccDAHistoND_classname()
	StatAccDAHistoND_classname = _npstat.StatAccDAHistoND_classname

	def StatAccDAHistoND_version() -> "unsigned int":
	return _npstat.StatAccDAHistoND_version()
	StatAccDAHistoND_version = _npstat.StatAccDAHistoND_version

	def StatAccDAHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::StatAccumulator,npstat::DualHistoAxis > *":
	return _npstat.StatAccDAHistoND_read(id, arg3)
	StatAccDAHistoND_read = _npstat.StatAccDAHistoND_read

	class WStatAccDAHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, WStatAccDAHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, WStatAccDAHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.WStatAccDAHistoND_SAMPLE
	SUM = _npstat.WStatAccDAHistoND_SUM
	AVERAGE = _npstat.WStatAccDAHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_WStatAccDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.WStatAccDAHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.WStatAccDAHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.WStatAccDAHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::WeightedStatAccumulator > const &":
	return _npstat.WStatAccDAHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::WeightedStatAccumulator > const &":
	return _npstat.WStatAccDAHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::DualHistoAxis,std::allocator< npstat::DualHistoAxis > > const &":
	return _npstat.WStatAccDAHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::DualHistoAxis const &":
	return _npstat.WStatAccDAHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.WStatAccDAHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.WStatAccDAHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.WStatAccDAHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.WStatAccDAHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.WStatAccDAHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.WStatAccDAHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.WStatAccDAHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.WStatAccDAHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.WStatAccDAHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.WStatAccDAHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.WStatAccDAHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.WStatAccDAHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.WStatAccDAHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.WStatAccDAHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.WStatAccDAHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.WStatAccDAHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'WStatAccDAHistoND') -> "bool":
	return _npstat.WStatAccDAHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'WStatAccDAHistoND') -> "bool":
	return _npstat.WStatAccDAHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'WStatAccDAHistoND') -> "bool":
	return _npstat.WStatAccDAHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.WStatAccDAHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.WStatAccDAHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::WeightedStatAccumulator,npstat::DualHistoAxis >":
	return _npstat.WStatAccDAHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.WStatAccDAHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.WStatAccDAHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.WStatAccDAHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.WStatAccDAHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.WStatAccDAHistoND_classname)
	else:
	classname = _npstat.WStatAccDAHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.WStatAccDAHistoND_version)
	else:
	version = _npstat.WStatAccDAHistoND_version
	if _newclass:
	read = staticmethod(_npstat.WStatAccDAHistoND_read)
	else:
	read = _npstat.WStatAccDAHistoND_read

	def examine(self, *args) -> "npstat::WeightedStatAccumulator":
	return _npstat.WStatAccDAHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::WeightedStatAccumulator":
	return _npstat.WStatAccDAHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.WStatAccDAHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'WeightedStatAccumulator') -> "void":
	return _npstat.WStatAccDAHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'WeightedStatAccumulator') -> "void":
	return _npstat.WStatAccDAHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'WeightedStatAccumulator') -> "void":
	return _npstat.WStatAccDAHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.WStatAccDAHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_WStatAccDAHistoND
	__del__ = lambda self: None
	WStatAccDAHistoND_swigregister = _npstat.WStatAccDAHistoND_swigregister
	WStatAccDAHistoND_swigregister(WStatAccDAHistoND)

	def WStatAccDAHistoND_classname() -> "char const *":
	return _npstat.WStatAccDAHistoND_classname()
	WStatAccDAHistoND_classname = _npstat.WStatAccDAHistoND_classname

	def WStatAccDAHistoND_version() -> "unsigned int":
	return _npstat.WStatAccDAHistoND_version()
	WStatAccDAHistoND_version = _npstat.WStatAccDAHistoND_version

	def WStatAccDAHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::WeightedStatAccumulator,npstat::DualHistoAxis > *":
	return _npstat.WStatAccDAHistoND_read(id, arg3)
	WStatAccDAHistoND_read = _npstat.WStatAccDAHistoND_read

	class BinSummaryDAHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, BinSummaryDAHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, BinSummaryDAHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.BinSummaryDAHistoND_SAMPLE
	SUM = _npstat.BinSummaryDAHistoND_SUM
	AVERAGE = _npstat.BinSummaryDAHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_BinSummaryDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.BinSummaryDAHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.BinSummaryDAHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.BinSummaryDAHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::BinSummary > const &":
	return _npstat.BinSummaryDAHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::BinSummary > const &":
	return _npstat.BinSummaryDAHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::DualHistoAxis,std::allocator< npstat::DualHistoAxis > > const &":
	return _npstat.BinSummaryDAHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::DualHistoAxis const &":
	return _npstat.BinSummaryDAHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.BinSummaryDAHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.BinSummaryDAHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.BinSummaryDAHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.BinSummaryDAHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.BinSummaryDAHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.BinSummaryDAHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.BinSummaryDAHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.BinSummaryDAHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.BinSummaryDAHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.BinSummaryDAHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.BinSummaryDAHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.BinSummaryDAHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.BinSummaryDAHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.BinSummaryDAHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.BinSummaryDAHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.BinSummaryDAHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'BinSummaryDAHistoND') -> "bool":
	return _npstat.BinSummaryDAHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'BinSummaryDAHistoND') -> "bool":
	return _npstat.BinSummaryDAHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'BinSummaryDAHistoND') -> "bool":
	return _npstat.BinSummaryDAHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.BinSummaryDAHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.BinSummaryDAHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::BinSummary,npstat::DualHistoAxis >":
	return _npstat.BinSummaryDAHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.BinSummaryDAHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.BinSummaryDAHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.BinSummaryDAHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.BinSummaryDAHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.BinSummaryDAHistoND_classname)
	else:
	classname = _npstat.BinSummaryDAHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.BinSummaryDAHistoND_version)
	else:
	version = _npstat.BinSummaryDAHistoND_version
	if _newclass:
	read = staticmethod(_npstat.BinSummaryDAHistoND_read)
	else:
	read = _npstat.BinSummaryDAHistoND_read

	def examine(self, *args) -> "npstat::BinSummary":
	return _npstat.BinSummaryDAHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::BinSummary":
	return _npstat.BinSummaryDAHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.BinSummaryDAHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'BinSummary') -> "void":
	return _npstat.BinSummaryDAHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'BinSummary') -> "void":
	return _npstat.BinSummaryDAHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'BinSummary') -> "void":
	return _npstat.BinSummaryDAHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.BinSummaryDAHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_BinSummaryDAHistoND
	__del__ = lambda self: None
	BinSummaryDAHistoND_swigregister = _npstat.BinSummaryDAHistoND_swigregister
	BinSummaryDAHistoND_swigregister(BinSummaryDAHistoND)

	def BinSummaryDAHistoND_classname() -> "char const *":
	return _npstat.BinSummaryDAHistoND_classname()
	BinSummaryDAHistoND_classname = _npstat.BinSummaryDAHistoND_classname

	def BinSummaryDAHistoND_version() -> "unsigned int":
	return _npstat.BinSummaryDAHistoND_version()
	BinSummaryDAHistoND_version = _npstat.BinSummaryDAHistoND_version

	def BinSummaryDAHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::BinSummary,npstat::DualHistoAxis > *":
	return _npstat.BinSummaryDAHistoND_read(id, arg3)
	BinSummaryDAHistoND_read = _npstat.BinSummaryDAHistoND_read

	class FSampleAccDAHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FSampleAccDAHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FSampleAccDAHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.FSampleAccDAHistoND_SAMPLE
	SUM = _npstat.FSampleAccDAHistoND_SUM
	AVERAGE = _npstat.FSampleAccDAHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_FSampleAccDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.FSampleAccDAHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.FSampleAccDAHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.FSampleAccDAHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::SampleAccumulator< float,long double > > const &":
	return _npstat.FSampleAccDAHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::SampleAccumulator< float,long double > > const &":
	return _npstat.FSampleAccDAHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::DualHistoAxis,std::allocator< npstat::DualHistoAxis > > const &":
	return _npstat.FSampleAccDAHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::DualHistoAxis const &":
	return _npstat.FSampleAccDAHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.FSampleAccDAHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.FSampleAccDAHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.FSampleAccDAHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.FSampleAccDAHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.FSampleAccDAHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.FSampleAccDAHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.FSampleAccDAHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.FSampleAccDAHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.FSampleAccDAHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.FSampleAccDAHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.FSampleAccDAHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.FSampleAccDAHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.FSampleAccDAHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.FSampleAccDAHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.FSampleAccDAHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.FSampleAccDAHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'FSampleAccDAHistoND') -> "bool":
	return _npstat.FSampleAccDAHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'FSampleAccDAHistoND') -> "bool":
	return _npstat.FSampleAccDAHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'FSampleAccDAHistoND') -> "bool":
	return _npstat.FSampleAccDAHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.FSampleAccDAHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.FSampleAccDAHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::FloatSampleAccumulator,npstat::DualHistoAxis >":
	return _npstat.FSampleAccDAHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.FSampleAccDAHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.FSampleAccDAHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.FSampleAccDAHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FSampleAccDAHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FSampleAccDAHistoND_classname)
	else:
	classname = _npstat.FSampleAccDAHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.FSampleAccDAHistoND_version)
	else:
	version = _npstat.FSampleAccDAHistoND_version
	if _newclass:
	read = staticmethod(_npstat.FSampleAccDAHistoND_read)
	else:
	read = _npstat.FSampleAccDAHistoND_read

	def examine(self, *args) -> "npstat::SampleAccumulator< float,long double >":
	return _npstat.FSampleAccDAHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::SampleAccumulator< float,long double >":
	return _npstat.FSampleAccDAHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.FSampleAccDAHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'FloatSampleAccumulator') -> "void":
	return _npstat.FSampleAccDAHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'FloatSampleAccumulator') -> "void":
	return _npstat.FSampleAccDAHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'FloatSampleAccumulator') -> "void":
	return _npstat.FSampleAccDAHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.FSampleAccDAHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_FSampleAccDAHistoND
	__del__ = lambda self: None
	FSampleAccDAHistoND_swigregister = _npstat.FSampleAccDAHistoND_swigregister
	FSampleAccDAHistoND_swigregister(FSampleAccDAHistoND)

	def FSampleAccDAHistoND_classname() -> "char const *":
	return _npstat.FSampleAccDAHistoND_classname()
	FSampleAccDAHistoND_classname = _npstat.FSampleAccDAHistoND_classname

	def FSampleAccDAHistoND_version() -> "unsigned int":
	return _npstat.FSampleAccDAHistoND_version()
	FSampleAccDAHistoND_version = _npstat.FSampleAccDAHistoND_version

	def FSampleAccDAHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::FloatSampleAccumulator,npstat::DualHistoAxis > *":
	return _npstat.FSampleAccDAHistoND_read(id, arg3)
	FSampleAccDAHistoND_read = _npstat.FSampleAccDAHistoND_read

	class DSampleAccDAHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DSampleAccDAHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DSampleAccDAHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.DSampleAccDAHistoND_SAMPLE
	SUM = _npstat.DSampleAccDAHistoND_SUM
	AVERAGE = _npstat.DSampleAccDAHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_DSampleAccDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.DSampleAccDAHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.DSampleAccDAHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.DSampleAccDAHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::SampleAccumulator< double,long double > > const &":
	return _npstat.DSampleAccDAHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::SampleAccumulator< double,long double > > const &":
	return _npstat.DSampleAccDAHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::DualHistoAxis,std::allocator< npstat::DualHistoAxis > > const &":
	return _npstat.DSampleAccDAHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::DualHistoAxis const &":
	return _npstat.DSampleAccDAHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.DSampleAccDAHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.DSampleAccDAHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.DSampleAccDAHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.DSampleAccDAHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.DSampleAccDAHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.DSampleAccDAHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.DSampleAccDAHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.DSampleAccDAHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.DSampleAccDAHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.DSampleAccDAHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.DSampleAccDAHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.DSampleAccDAHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.DSampleAccDAHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.DSampleAccDAHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.DSampleAccDAHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.DSampleAccDAHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'DSampleAccDAHistoND') -> "bool":
	return _npstat.DSampleAccDAHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'DSampleAccDAHistoND') -> "bool":
	return _npstat.DSampleAccDAHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'DSampleAccDAHistoND') -> "bool":
	return _npstat.DSampleAccDAHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.DSampleAccDAHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.DSampleAccDAHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::DualHistoAxis >":
	return _npstat.DSampleAccDAHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.DSampleAccDAHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.DSampleAccDAHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.DSampleAccDAHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DSampleAccDAHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DSampleAccDAHistoND_classname)
	else:
	classname = _npstat.DSampleAccDAHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.DSampleAccDAHistoND_version)
	else:
	version = _npstat.DSampleAccDAHistoND_version
	if _newclass:
	read = staticmethod(_npstat.DSampleAccDAHistoND_read)
	else:
	read = _npstat.DSampleAccDAHistoND_read

	def examine(self, *args) -> "npstat::SampleAccumulator< double,long double >":
	return _npstat.DSampleAccDAHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::SampleAccumulator< double,long double >":
	return _npstat.DSampleAccDAHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.DSampleAccDAHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'DoubleSampleAccumulator') -> "void":
	return _npstat.DSampleAccDAHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'DoubleSampleAccumulator') -> "void":
	return _npstat.DSampleAccDAHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'DoubleSampleAccumulator') -> "void":
	return _npstat.DSampleAccDAHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.DSampleAccDAHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_DSampleAccDAHistoND
	__del__ = lambda self: None
	DSampleAccDAHistoND_swigregister = _npstat.DSampleAccDAHistoND_swigregister
	DSampleAccDAHistoND_swigregister(DSampleAccDAHistoND)

	def DSampleAccDAHistoND_classname() -> "char const *":
	return _npstat.DSampleAccDAHistoND_classname()
	DSampleAccDAHistoND_classname = _npstat.DSampleAccDAHistoND_classname

	def DSampleAccDAHistoND_version() -> "unsigned int":
	return _npstat.DSampleAccDAHistoND_version()
	DSampleAccDAHistoND_version = _npstat.DSampleAccDAHistoND_version

	def DSampleAccDAHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::DualHistoAxis > *":
	return _npstat.DSampleAccDAHistoND_read(id, arg3)
	DSampleAccDAHistoND_read = _npstat.DSampleAccDAHistoND_read

	class DWSampleAccDAHistoND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DWSampleAccDAHistoND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DWSampleAccDAHistoND, name)
	__repr__ = _swig_repr
	SAMPLE = _npstat.DWSampleAccDAHistoND_SAMPLE
	SUM = _npstat.DWSampleAccDAHistoND_SUM
	AVERAGE = _npstat.DWSampleAccDAHistoND_AVERAGE

	def __init__(self, *args):
	this = _npstat.new_DWSampleAccDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.DWSampleAccDAHistoND_dim(self)

	def title(self) -> "std::string const &":
	return _npstat.DWSampleAccDAHistoND_title(self)

	def accumulatedDataLabel(self) -> "std::string const &":
	return _npstat.DWSampleAccDAHistoND_accumulatedDataLabel(self)

	def binContents(self) -> "npstat::ArrayND< npstat::WeightedSampleAccumulator< double,long double > > const &":
	return _npstat.DWSampleAccDAHistoND_binContents(self)

	def overflows(self) -> "npstat::ArrayND< npstat::WeightedSampleAccumulator< double,long double > > const &":
	return _npstat.DWSampleAccDAHistoND_overflows(self)

	def axes(self) -> "std::vector< npstat::DualHistoAxis,std::allocator< npstat::DualHistoAxis > > const &":
	return _npstat.DWSampleAccDAHistoND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::DualHistoAxis const &":
	return _npstat.DWSampleAccDAHistoND_axis(self, i)

	def nBins(self) -> "unsigned long":
	return _npstat.DWSampleAccDAHistoND_nBins(self)

	def nFillsTotal(self) -> "unsigned long":
	return _npstat.DWSampleAccDAHistoND_nFillsTotal(self)

	def nFillsInRange(self) -> "unsigned long":
	return _npstat.DWSampleAccDAHistoND_nFillsInRange(self)

	def nFillsOver(self) -> "unsigned long":
	return _npstat.DWSampleAccDAHistoND_nFillsOver(self)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.DWSampleAccDAHistoND_isUniformlyBinned(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.DWSampleAccDAHistoND_setTitle(self, newtitle)

	def setAccumulatedDataLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.DWSampleAccDAHistoND_setAccumulatedDataLabel(self, newlabel)

	def setAxisLabel(self, axisNum: 'unsigned int const', newlabel: 'char const *') -> "void":
	return _npstat.DWSampleAccDAHistoND_setAxisLabel(self, axisNum, newlabel)

	def binVolume(self, binNumber: 'unsigned long'=0) -> "double":
	return _npstat.DWSampleAccDAHistoND_binVolume(self, binNumber)

	def binCenter(self, binNumber: 'unsigned long', coords: 'double *', lenCoords: 'unsigned int') -> "void":
	return _npstat.DWSampleAccDAHistoND_binCenter(self, binNumber, coords, lenCoords)

	def binBox(self, binNumber: 'unsigned long', box: 'DoubleBoxND') -> "void":
	return _npstat.DWSampleAccDAHistoND_binBox(self, binNumber, box)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.DWSampleAccDAHistoND_boundingBox(self)

	def volume(self) -> "double":
	return _npstat.DWSampleAccDAHistoND_volume(self)

	def clear(self) -> "void":
	return _npstat.DWSampleAccDAHistoND_clear(self)

	def clearBinContents(self) -> "void":
	return _npstat.DWSampleAccDAHistoND_clearBinContents(self)

	def clearOverflows(self) -> "void":
	return _npstat.DWSampleAccDAHistoND_clearOverflows(self)

	def __eq__(self, arg2: 'DWSampleAccDAHistoND') -> "bool":
	return _npstat.DWSampleAccDAHistoND___eq__(self, arg2)

	def __ne__(self, arg2: 'DWSampleAccDAHistoND') -> "bool":
	return _npstat.DWSampleAccDAHistoND___ne__(self, arg2)

	def isSameData(self, arg2: 'DWSampleAccDAHistoND') -> "bool":
	return _npstat.DWSampleAccDAHistoND_isSameData(self, arg2)

	def setNFillsTotal(self, i: 'unsigned long const') -> "void":
	return _npstat.DWSampleAccDAHistoND_setNFillsTotal(self, i)

	def setNFillsOver(self, i: 'unsigned long const') -> "void":
	return _npstat.DWSampleAccDAHistoND_setNFillsOver(self, i)

	def transpose(self, axisNum1: 'unsigned int', axisNum2: 'unsigned int') -> "npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::DualHistoAxis >":
	return _npstat.DWSampleAccDAHistoND_transpose(self, axisNum1, axisNum2)

	def getModCount(self) -> "unsigned long":
	return _npstat.DWSampleAccDAHistoND_getModCount(self)

	def incrModCount(self) -> "void":
	return _npstat.DWSampleAccDAHistoND_incrModCount(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.DWSampleAccDAHistoND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DWSampleAccDAHistoND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DWSampleAccDAHistoND_classname)
	else:
	classname = _npstat.DWSampleAccDAHistoND_classname
	if _newclass:
	version = staticmethod(_npstat.DWSampleAccDAHistoND_version)
	else:
	version = _npstat.DWSampleAccDAHistoND_version
	if _newclass:
	read = staticmethod(_npstat.DWSampleAccDAHistoND_read)
	else:
	read = _npstat.DWSampleAccDAHistoND_read

	def examine(self, *args) -> "npstat::WeightedSampleAccumulator< double,long double >":
	return _npstat.DWSampleAccDAHistoND_examine(self, *args)

	def closestBin(self, *args) -> "npstat::WeightedSampleAccumulator< double,long double >":
	return _npstat.DWSampleAccDAHistoND_closestBin(self, *args)

	def setBin(self, *args) -> "void":
	return _npstat.DWSampleAccDAHistoND_setBin(self, *args)

	def setLinearBin(self, index: 'unsigned long const', v: 'DoubleWeightedSampleAccumulator') -> "void":
	return _npstat.DWSampleAccDAHistoND_setLinearBin(self, index, v)

	def setBinsToConst(self, value: 'DoubleWeightedSampleAccumulator') -> "void":
	return _npstat.DWSampleAccDAHistoND_setBinsToConst(self, value)

	def setOverflowsToConst(self, value: 'DoubleWeightedSampleAccumulator') -> "void":
	return _npstat.DWSampleAccDAHistoND_setOverflowsToConst(self, value)

	def fill(self, *args) -> "void":
	return _npstat.DWSampleAccDAHistoND_fill(self, *args)
	__swig_destroy__ = _npstat.delete_DWSampleAccDAHistoND
	__del__ = lambda self: None
	DWSampleAccDAHistoND_swigregister = _npstat.DWSampleAccDAHistoND_swigregister
	DWSampleAccDAHistoND_swigregister(DWSampleAccDAHistoND)

	def DWSampleAccDAHistoND_classname() -> "char const *":
	return _npstat.DWSampleAccDAHistoND_classname()
	DWSampleAccDAHistoND_classname = _npstat.DWSampleAccDAHistoND_classname

	def DWSampleAccDAHistoND_version() -> "unsigned int":
	return _npstat.DWSampleAccDAHistoND_version()
	DWSampleAccDAHistoND_version = _npstat.DWSampleAccDAHistoND_version

	def DWSampleAccDAHistoND_read(id: 'ClassId', arg3: 'istream') -> "npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::DualHistoAxis > *":
	return _npstat.DWSampleAccDAHistoND_read(id, arg3)
	DWSampleAccDAHistoND_read = _npstat.DWSampleAccDAHistoND_read

	class ArchiveRecord_UCharHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_UCharHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_UCharHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'UCharHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_UCharHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_UCharHistoND
	__del__ = lambda self: None
	ArchiveRecord_UCharHistoND_swigregister = _npstat.ArchiveRecord_UCharHistoND_swigregister
	ArchiveRecord_UCharHistoND_swigregister(ArchiveRecord_UCharHistoND)

	class Ref_UCharHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_UCharHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_UCharHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_UCharHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'UCharHistoND') -> "void":
	return _npstat.Ref_UCharHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< unsigned char,npstat::HistoAxis > *":
	return _npstat.Ref_UCharHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< unsigned char,npstat::HistoAxis >":
	return _npstat.Ref_UCharHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_UCharHistoND
	__del__ = lambda self: None
	Ref_UCharHistoND_swigregister = _npstat.Ref_UCharHistoND_swigregister
	Ref_UCharHistoND_swigregister(Ref_UCharHistoND)

	class ArchiveRecord_UCharNUHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_UCharNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_UCharNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'UCharNUHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_UCharNUHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_UCharNUHistoND
	__del__ = lambda self: None
	ArchiveRecord_UCharNUHistoND_swigregister = _npstat.ArchiveRecord_UCharNUHistoND_swigregister
	ArchiveRecord_UCharNUHistoND_swigregister(ArchiveRecord_UCharNUHistoND)

	class Ref_UCharNUHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_UCharNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_UCharNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_UCharNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'UCharNUHistoND') -> "void":
	return _npstat.Ref_UCharNUHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< unsigned char,npstat::NUHistoAxis > *":
	return _npstat.Ref_UCharNUHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< unsigned char,npstat::NUHistoAxis >":
	return _npstat.Ref_UCharNUHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_UCharNUHistoND
	__del__ = lambda self: None
	Ref_UCharNUHistoND_swigregister = _npstat.Ref_UCharNUHistoND_swigregister
	Ref_UCharNUHistoND_swigregister(Ref_UCharNUHistoND)

	class ArchiveRecord_UCharDAHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_UCharDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_UCharDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'UCharDAHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_UCharDAHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_UCharDAHistoND
	__del__ = lambda self: None
	ArchiveRecord_UCharDAHistoND_swigregister = _npstat.ArchiveRecord_UCharDAHistoND_swigregister
	ArchiveRecord_UCharDAHistoND_swigregister(ArchiveRecord_UCharDAHistoND)

	class Ref_UCharDAHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_UCharDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_UCharDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_UCharDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'UCharDAHistoND') -> "void":
	return _npstat.Ref_UCharDAHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< unsigned char,npstat::DualHistoAxis > *":
	return _npstat.Ref_UCharDAHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< unsigned char,npstat::DualHistoAxis >":
	return _npstat.Ref_UCharDAHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_UCharDAHistoND
	__del__ = lambda self: None
	Ref_UCharDAHistoND_swigregister = _npstat.Ref_UCharDAHistoND_swigregister
	Ref_UCharDAHistoND_swigregister(Ref_UCharDAHistoND)

	class ArchiveRecord_IntHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_IntHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_IntHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'IntHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_IntHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_IntHistoND
	__del__ = lambda self: None
	ArchiveRecord_IntHistoND_swigregister = _npstat.ArchiveRecord_IntHistoND_swigregister
	ArchiveRecord_IntHistoND_swigregister(ArchiveRecord_IntHistoND)

	class Ref_IntHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_IntHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_IntHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_IntHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'IntHistoND') -> "void":
	return _npstat.Ref_IntHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< int,npstat::HistoAxis > *":
	return _npstat.Ref_IntHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< int,npstat::HistoAxis >":
	return _npstat.Ref_IntHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_IntHistoND
	__del__ = lambda self: None
	Ref_IntHistoND_swigregister = _npstat.Ref_IntHistoND_swigregister
	Ref_IntHistoND_swigregister(Ref_IntHistoND)

	class ArchiveRecord_IntNUHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_IntNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_IntNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'IntNUHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_IntNUHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_IntNUHistoND
	__del__ = lambda self: None
	ArchiveRecord_IntNUHistoND_swigregister = _npstat.ArchiveRecord_IntNUHistoND_swigregister
	ArchiveRecord_IntNUHistoND_swigregister(ArchiveRecord_IntNUHistoND)

	class Ref_IntNUHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_IntNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_IntNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_IntNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'IntNUHistoND') -> "void":
	return _npstat.Ref_IntNUHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< int,npstat::NUHistoAxis > *":
	return _npstat.Ref_IntNUHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< int,npstat::NUHistoAxis >":
	return _npstat.Ref_IntNUHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_IntNUHistoND
	__del__ = lambda self: None
	Ref_IntNUHistoND_swigregister = _npstat.Ref_IntNUHistoND_swigregister
	Ref_IntNUHistoND_swigregister(Ref_IntNUHistoND)

	class ArchiveRecord_IntDAHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_IntDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_IntDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'IntDAHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_IntDAHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_IntDAHistoND
	__del__ = lambda self: None
	ArchiveRecord_IntDAHistoND_swigregister = _npstat.ArchiveRecord_IntDAHistoND_swigregister
	ArchiveRecord_IntDAHistoND_swigregister(ArchiveRecord_IntDAHistoND)

	class Ref_IntDAHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_IntDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_IntDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_IntDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'IntDAHistoND') -> "void":
	return _npstat.Ref_IntDAHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< int,npstat::DualHistoAxis > *":
	return _npstat.Ref_IntDAHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< int,npstat::DualHistoAxis >":
	return _npstat.Ref_IntDAHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_IntDAHistoND
	__del__ = lambda self: None
	Ref_IntDAHistoND_swigregister = _npstat.Ref_IntDAHistoND_swigregister
	Ref_IntDAHistoND_swigregister(Ref_IntDAHistoND)

	class ArchiveRecord_LLongHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_LLongHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_LLongHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'LLongHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_LLongHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_LLongHistoND
	__del__ = lambda self: None
	ArchiveRecord_LLongHistoND_swigregister = _npstat.ArchiveRecord_LLongHistoND_swigregister
	ArchiveRecord_LLongHistoND_swigregister(ArchiveRecord_LLongHistoND)

	class Ref_LLongHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_LLongHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_LLongHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_LLongHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'LLongHistoND') -> "void":
	return _npstat.Ref_LLongHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< long long,npstat::HistoAxis > *":
	return _npstat.Ref_LLongHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< long long,npstat::HistoAxis >":
	return _npstat.Ref_LLongHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_LLongHistoND
	__del__ = lambda self: None
	Ref_LLongHistoND_swigregister = _npstat.Ref_LLongHistoND_swigregister
	Ref_LLongHistoND_swigregister(Ref_LLongHistoND)

	class ArchiveRecord_LLongNUHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_LLongNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_LLongNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'LLongNUHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_LLongNUHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_LLongNUHistoND
	__del__ = lambda self: None
	ArchiveRecord_LLongNUHistoND_swigregister = _npstat.ArchiveRecord_LLongNUHistoND_swigregister
	ArchiveRecord_LLongNUHistoND_swigregister(ArchiveRecord_LLongNUHistoND)

	class Ref_LLongNUHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_LLongNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_LLongNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_LLongNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'LLongNUHistoND') -> "void":
	return _npstat.Ref_LLongNUHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< long long,npstat::NUHistoAxis > *":
	return _npstat.Ref_LLongNUHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< long long,npstat::NUHistoAxis >":
	return _npstat.Ref_LLongNUHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_LLongNUHistoND
	__del__ = lambda self: None
	Ref_LLongNUHistoND_swigregister = _npstat.Ref_LLongNUHistoND_swigregister
	Ref_LLongNUHistoND_swigregister(Ref_LLongNUHistoND)

	class ArchiveRecord_LLongDAHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_LLongDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_LLongDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'LLongDAHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_LLongDAHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_LLongDAHistoND
	__del__ = lambda self: None
	ArchiveRecord_LLongDAHistoND_swigregister = _npstat.ArchiveRecord_LLongDAHistoND_swigregister
	ArchiveRecord_LLongDAHistoND_swigregister(ArchiveRecord_LLongDAHistoND)

	class Ref_LLongDAHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_LLongDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_LLongDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_LLongDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'LLongDAHistoND') -> "void":
	return _npstat.Ref_LLongDAHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< long long,npstat::DualHistoAxis > *":
	return _npstat.Ref_LLongDAHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< long long,npstat::DualHistoAxis >":
	return _npstat.Ref_LLongDAHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_LLongDAHistoND
	__del__ = lambda self: None
	Ref_LLongDAHistoND_swigregister = _npstat.Ref_LLongDAHistoND_swigregister
	Ref_LLongDAHistoND_swigregister(Ref_LLongDAHistoND)

	class ArchiveRecord_FloatHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_FloatHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_FloatHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'FloatHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_FloatHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_FloatHistoND
	__del__ = lambda self: None
	ArchiveRecord_FloatHistoND_swigregister = _npstat.ArchiveRecord_FloatHistoND_swigregister
	ArchiveRecord_FloatHistoND_swigregister(ArchiveRecord_FloatHistoND)

	class Ref_FloatHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_FloatHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_FloatHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_FloatHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'FloatHistoND') -> "void":
	return _npstat.Ref_FloatHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< float,npstat::HistoAxis > *":
	return _npstat.Ref_FloatHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< float,npstat::HistoAxis >":
	return _npstat.Ref_FloatHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_FloatHistoND
	__del__ = lambda self: None
	Ref_FloatHistoND_swigregister = _npstat.Ref_FloatHistoND_swigregister
	Ref_FloatHistoND_swigregister(Ref_FloatHistoND)

	class ArchiveRecord_FloatNUHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_FloatNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_FloatNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'FloatNUHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_FloatNUHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_FloatNUHistoND
	__del__ = lambda self: None
	ArchiveRecord_FloatNUHistoND_swigregister = _npstat.ArchiveRecord_FloatNUHistoND_swigregister
	ArchiveRecord_FloatNUHistoND_swigregister(ArchiveRecord_FloatNUHistoND)

	class Ref_FloatNUHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_FloatNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_FloatNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_FloatNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'FloatNUHistoND') -> "void":
	return _npstat.Ref_FloatNUHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< float,npstat::NUHistoAxis > *":
	return _npstat.Ref_FloatNUHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< float,npstat::NUHistoAxis >":
	return _npstat.Ref_FloatNUHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_FloatNUHistoND
	__del__ = lambda self: None
	Ref_FloatNUHistoND_swigregister = _npstat.Ref_FloatNUHistoND_swigregister
	Ref_FloatNUHistoND_swigregister(Ref_FloatNUHistoND)

	class ArchiveRecord_FloatDAHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_FloatDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_FloatDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'FloatDAHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_FloatDAHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_FloatDAHistoND
	__del__ = lambda self: None
	ArchiveRecord_FloatDAHistoND_swigregister = _npstat.ArchiveRecord_FloatDAHistoND_swigregister
	ArchiveRecord_FloatDAHistoND_swigregister(ArchiveRecord_FloatDAHistoND)

	class Ref_FloatDAHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_FloatDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_FloatDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_FloatDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'FloatDAHistoND') -> "void":
	return _npstat.Ref_FloatDAHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< float,npstat::DualHistoAxis > *":
	return _npstat.Ref_FloatDAHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< float,npstat::DualHistoAxis >":
	return _npstat.Ref_FloatDAHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_FloatDAHistoND
	__del__ = lambda self: None
	Ref_FloatDAHistoND_swigregister = _npstat.Ref_FloatDAHistoND_swigregister
	Ref_FloatDAHistoND_swigregister(Ref_FloatDAHistoND)

	class ArchiveRecord_DoubleHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DoubleHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DoubleHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DoubleHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DoubleHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DoubleHistoND
	__del__ = lambda self: None
	ArchiveRecord_DoubleHistoND_swigregister = _npstat.ArchiveRecord_DoubleHistoND_swigregister
	ArchiveRecord_DoubleHistoND_swigregister(ArchiveRecord_DoubleHistoND)

	class Ref_DoubleHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DoubleHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DoubleHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DoubleHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DoubleHistoND') -> "void":
	return _npstat.Ref_DoubleHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< double,npstat::HistoAxis > *":
	return _npstat.Ref_DoubleHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< double,npstat::HistoAxis >":
	return _npstat.Ref_DoubleHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DoubleHistoND
	__del__ = lambda self: None
	Ref_DoubleHistoND_swigregister = _npstat.Ref_DoubleHistoND_swigregister
	Ref_DoubleHistoND_swigregister(Ref_DoubleHistoND)

	class ArchiveRecord_DoubleNUHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DoubleNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DoubleNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DoubleNUHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DoubleNUHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DoubleNUHistoND
	__del__ = lambda self: None
	ArchiveRecord_DoubleNUHistoND_swigregister = _npstat.ArchiveRecord_DoubleNUHistoND_swigregister
	ArchiveRecord_DoubleNUHistoND_swigregister(ArchiveRecord_DoubleNUHistoND)

	class Ref_DoubleNUHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DoubleNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DoubleNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DoubleNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DoubleNUHistoND') -> "void":
	return _npstat.Ref_DoubleNUHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< double,npstat::NUHistoAxis > *":
	return _npstat.Ref_DoubleNUHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< double,npstat::NUHistoAxis >":
	return _npstat.Ref_DoubleNUHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DoubleNUHistoND
	__del__ = lambda self: None
	Ref_DoubleNUHistoND_swigregister = _npstat.Ref_DoubleNUHistoND_swigregister
	Ref_DoubleNUHistoND_swigregister(Ref_DoubleNUHistoND)

	class ArchiveRecord_DoubleDAHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DoubleDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DoubleDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DoubleDAHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DoubleDAHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DoubleDAHistoND
	__del__ = lambda self: None
	ArchiveRecord_DoubleDAHistoND_swigregister = _npstat.ArchiveRecord_DoubleDAHistoND_swigregister
	ArchiveRecord_DoubleDAHistoND_swigregister(ArchiveRecord_DoubleDAHistoND)

	class Ref_DoubleDAHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DoubleDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DoubleDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DoubleDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DoubleDAHistoND') -> "void":
	return _npstat.Ref_DoubleDAHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< double,npstat::DualHistoAxis > *":
	return _npstat.Ref_DoubleDAHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< double,npstat::DualHistoAxis >":
	return _npstat.Ref_DoubleDAHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DoubleDAHistoND
	__del__ = lambda self: None
	Ref_DoubleDAHistoND_swigregister = _npstat.Ref_DoubleDAHistoND_swigregister
	Ref_DoubleDAHistoND_swigregister(Ref_DoubleDAHistoND)

	class ArchiveRecord_StatAccHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_StatAccHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_StatAccHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'StatAccHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_StatAccHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_StatAccHistoND
	__del__ = lambda self: None
	ArchiveRecord_StatAccHistoND_swigregister = _npstat.ArchiveRecord_StatAccHistoND_swigregister
	ArchiveRecord_StatAccHistoND_swigregister(ArchiveRecord_StatAccHistoND)

	class Ref_StatAccHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_StatAccHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_StatAccHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_StatAccHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'StatAccHistoND') -> "void":
	return _npstat.Ref_StatAccHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::StatAccumulator,npstat::HistoAxis > *":
	return _npstat.Ref_StatAccHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::StatAccumulator,npstat::HistoAxis >":
	return _npstat.Ref_StatAccHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_StatAccHistoND
	__del__ = lambda self: None
	Ref_StatAccHistoND_swigregister = _npstat.Ref_StatAccHistoND_swigregister
	Ref_StatAccHistoND_swigregister(Ref_StatAccHistoND)

	class ArchiveRecord_StatAccNUHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_StatAccNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_StatAccNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'StatAccNUHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_StatAccNUHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_StatAccNUHistoND
	__del__ = lambda self: None
	ArchiveRecord_StatAccNUHistoND_swigregister = _npstat.ArchiveRecord_StatAccNUHistoND_swigregister
	ArchiveRecord_StatAccNUHistoND_swigregister(ArchiveRecord_StatAccNUHistoND)

	class Ref_StatAccNUHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_StatAccNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_StatAccNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_StatAccNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'StatAccNUHistoND') -> "void":
	return _npstat.Ref_StatAccNUHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::StatAccumulator,npstat::NUHistoAxis > *":
	return _npstat.Ref_StatAccNUHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::StatAccumulator,npstat::NUHistoAxis >":
	return _npstat.Ref_StatAccNUHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_StatAccNUHistoND
	__del__ = lambda self: None
	Ref_StatAccNUHistoND_swigregister = _npstat.Ref_StatAccNUHistoND_swigregister
	Ref_StatAccNUHistoND_swigregister(Ref_StatAccNUHistoND)

	class ArchiveRecord_StatAccDAHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_StatAccDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_StatAccDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'StatAccDAHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_StatAccDAHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_StatAccDAHistoND
	__del__ = lambda self: None
	ArchiveRecord_StatAccDAHistoND_swigregister = _npstat.ArchiveRecord_StatAccDAHistoND_swigregister
	ArchiveRecord_StatAccDAHistoND_swigregister(ArchiveRecord_StatAccDAHistoND)

	class Ref_StatAccDAHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_StatAccDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_StatAccDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_StatAccDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'StatAccDAHistoND') -> "void":
	return _npstat.Ref_StatAccDAHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::StatAccumulator,npstat::DualHistoAxis > *":
	return _npstat.Ref_StatAccDAHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::StatAccumulator,npstat::DualHistoAxis >":
	return _npstat.Ref_StatAccDAHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_StatAccDAHistoND
	__del__ = lambda self: None
	Ref_StatAccDAHistoND_swigregister = _npstat.Ref_StatAccDAHistoND_swigregister
	Ref_StatAccDAHistoND_swigregister(Ref_StatAccDAHistoND)

	class ArchiveRecord_WStatAccHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_WStatAccHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_WStatAccHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'WStatAccHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_WStatAccHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_WStatAccHistoND
	__del__ = lambda self: None
	ArchiveRecord_WStatAccHistoND_swigregister = _npstat.ArchiveRecord_WStatAccHistoND_swigregister
	ArchiveRecord_WStatAccHistoND_swigregister(ArchiveRecord_WStatAccHistoND)

	class Ref_WStatAccHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_WStatAccHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_WStatAccHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_WStatAccHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'WStatAccHistoND') -> "void":
	return _npstat.Ref_WStatAccHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::WeightedStatAccumulator,npstat::HistoAxis > *":
	return _npstat.Ref_WStatAccHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::WeightedStatAccumulator,npstat::HistoAxis >":
	return _npstat.Ref_WStatAccHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_WStatAccHistoND
	__del__ = lambda self: None
	Ref_WStatAccHistoND_swigregister = _npstat.Ref_WStatAccHistoND_swigregister
	Ref_WStatAccHistoND_swigregister(Ref_WStatAccHistoND)

	class ArchiveRecord_WStatAccNUHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_WStatAccNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_WStatAccNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'WStatAccNUHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_WStatAccNUHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_WStatAccNUHistoND
	__del__ = lambda self: None
	ArchiveRecord_WStatAccNUHistoND_swigregister = _npstat.ArchiveRecord_WStatAccNUHistoND_swigregister
	ArchiveRecord_WStatAccNUHistoND_swigregister(ArchiveRecord_WStatAccNUHistoND)

	class Ref_WStatAccNUHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_WStatAccNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_WStatAccNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_WStatAccNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'WStatAccNUHistoND') -> "void":
	return _npstat.Ref_WStatAccNUHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::WeightedStatAccumulator,npstat::NUHistoAxis > *":
	return _npstat.Ref_WStatAccNUHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::WeightedStatAccumulator,npstat::NUHistoAxis >":
	return _npstat.Ref_WStatAccNUHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_WStatAccNUHistoND
	__del__ = lambda self: None
	Ref_WStatAccNUHistoND_swigregister = _npstat.Ref_WStatAccNUHistoND_swigregister
	Ref_WStatAccNUHistoND_swigregister(Ref_WStatAccNUHistoND)

	class ArchiveRecord_WStatAccDAHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_WStatAccDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_WStatAccDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'WStatAccDAHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_WStatAccDAHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_WStatAccDAHistoND
	__del__ = lambda self: None
	ArchiveRecord_WStatAccDAHistoND_swigregister = _npstat.ArchiveRecord_WStatAccDAHistoND_swigregister
	ArchiveRecord_WStatAccDAHistoND_swigregister(ArchiveRecord_WStatAccDAHistoND)

	class Ref_WStatAccDAHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_WStatAccDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_WStatAccDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_WStatAccDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'WStatAccDAHistoND') -> "void":
	return _npstat.Ref_WStatAccDAHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::WeightedStatAccumulator,npstat::DualHistoAxis > *":
	return _npstat.Ref_WStatAccDAHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::WeightedStatAccumulator,npstat::DualHistoAxis >":
	return _npstat.Ref_WStatAccDAHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_WStatAccDAHistoND
	__del__ = lambda self: None
	Ref_WStatAccDAHistoND_swigregister = _npstat.Ref_WStatAccDAHistoND_swigregister
	Ref_WStatAccDAHistoND_swigregister(Ref_WStatAccDAHistoND)

	class ArchiveRecord_BinSummaryHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_BinSummaryHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_BinSummaryHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'BinSummaryHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_BinSummaryHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_BinSummaryHistoND
	__del__ = lambda self: None
	ArchiveRecord_BinSummaryHistoND_swigregister = _npstat.ArchiveRecord_BinSummaryHistoND_swigregister
	ArchiveRecord_BinSummaryHistoND_swigregister(ArchiveRecord_BinSummaryHistoND)

	class Ref_BinSummaryHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_BinSummaryHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_BinSummaryHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_BinSummaryHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'BinSummaryHistoND') -> "void":
	return _npstat.Ref_BinSummaryHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::BinSummary,npstat::HistoAxis > *":
	return _npstat.Ref_BinSummaryHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::BinSummary,npstat::HistoAxis >":
	return _npstat.Ref_BinSummaryHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_BinSummaryHistoND
	__del__ = lambda self: None
	Ref_BinSummaryHistoND_swigregister = _npstat.Ref_BinSummaryHistoND_swigregister
	Ref_BinSummaryHistoND_swigregister(Ref_BinSummaryHistoND)

	class ArchiveRecord_BinSummaryNUHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_BinSummaryNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_BinSummaryNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'BinSummaryNUHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_BinSummaryNUHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_BinSummaryNUHistoND
	__del__ = lambda self: None
	ArchiveRecord_BinSummaryNUHistoND_swigregister = _npstat.ArchiveRecord_BinSummaryNUHistoND_swigregister
	ArchiveRecord_BinSummaryNUHistoND_swigregister(ArchiveRecord_BinSummaryNUHistoND)

	class Ref_BinSummaryNUHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_BinSummaryNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_BinSummaryNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_BinSummaryNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'BinSummaryNUHistoND') -> "void":
	return _npstat.Ref_BinSummaryNUHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::BinSummary,npstat::NUHistoAxis > *":
	return _npstat.Ref_BinSummaryNUHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::BinSummary,npstat::NUHistoAxis >":
	return _npstat.Ref_BinSummaryNUHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_BinSummaryNUHistoND
	__del__ = lambda self: None
	Ref_BinSummaryNUHistoND_swigregister = _npstat.Ref_BinSummaryNUHistoND_swigregister
	Ref_BinSummaryNUHistoND_swigregister(Ref_BinSummaryNUHistoND)

	class ArchiveRecord_BinSummaryDAHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_BinSummaryDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_BinSummaryDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'BinSummaryDAHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_BinSummaryDAHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_BinSummaryDAHistoND
	__del__ = lambda self: None
	ArchiveRecord_BinSummaryDAHistoND_swigregister = _npstat.ArchiveRecord_BinSummaryDAHistoND_swigregister
	ArchiveRecord_BinSummaryDAHistoND_swigregister(ArchiveRecord_BinSummaryDAHistoND)

	class Ref_BinSummaryDAHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_BinSummaryDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_BinSummaryDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_BinSummaryDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'BinSummaryDAHistoND') -> "void":
	return _npstat.Ref_BinSummaryDAHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::BinSummary,npstat::DualHistoAxis > *":
	return _npstat.Ref_BinSummaryDAHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::BinSummary,npstat::DualHistoAxis >":
	return _npstat.Ref_BinSummaryDAHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_BinSummaryDAHistoND
	__del__ = lambda self: None
	Ref_BinSummaryDAHistoND_swigregister = _npstat.Ref_BinSummaryDAHistoND_swigregister
	Ref_BinSummaryDAHistoND_swigregister(Ref_BinSummaryDAHistoND)

	class ArchiveRecord_FSampleAccHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_FSampleAccHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_FSampleAccHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'FSampleAccHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_FSampleAccHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_FSampleAccHistoND
	__del__ = lambda self: None
	ArchiveRecord_FSampleAccHistoND_swigregister = _npstat.ArchiveRecord_FSampleAccHistoND_swigregister
	ArchiveRecord_FSampleAccHistoND_swigregister(ArchiveRecord_FSampleAccHistoND)

	class Ref_FSampleAccHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_FSampleAccHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_FSampleAccHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_FSampleAccHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'FSampleAccHistoND') -> "void":
	return _npstat.Ref_FSampleAccHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::FloatSampleAccumulator,npstat::HistoAxis > *":
	return _npstat.Ref_FSampleAccHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::FloatSampleAccumulator,npstat::HistoAxis >":
	return _npstat.Ref_FSampleAccHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_FSampleAccHistoND
	__del__ = lambda self: None
	Ref_FSampleAccHistoND_swigregister = _npstat.Ref_FSampleAccHistoND_swigregister
	Ref_FSampleAccHistoND_swigregister(Ref_FSampleAccHistoND)

	class ArchiveRecord_FSampleAccNUHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_FSampleAccNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_FSampleAccNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'FSampleAccNUHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_FSampleAccNUHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_FSampleAccNUHistoND
	__del__ = lambda self: None
	ArchiveRecord_FSampleAccNUHistoND_swigregister = _npstat.ArchiveRecord_FSampleAccNUHistoND_swigregister
	ArchiveRecord_FSampleAccNUHistoND_swigregister(ArchiveRecord_FSampleAccNUHistoND)

	class Ref_FSampleAccNUHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_FSampleAccNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_FSampleAccNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_FSampleAccNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'FSampleAccNUHistoND') -> "void":
	return _npstat.Ref_FSampleAccNUHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::FloatSampleAccumulator,npstat::NUHistoAxis > *":
	return _npstat.Ref_FSampleAccNUHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::FloatSampleAccumulator,npstat::NUHistoAxis >":
	return _npstat.Ref_FSampleAccNUHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_FSampleAccNUHistoND
	__del__ = lambda self: None
	Ref_FSampleAccNUHistoND_swigregister = _npstat.Ref_FSampleAccNUHistoND_swigregister
	Ref_FSampleAccNUHistoND_swigregister(Ref_FSampleAccNUHistoND)

	class ArchiveRecord_FSampleAccDAHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_FSampleAccDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_FSampleAccDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'FSampleAccDAHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_FSampleAccDAHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_FSampleAccDAHistoND
	__del__ = lambda self: None
	ArchiveRecord_FSampleAccDAHistoND_swigregister = _npstat.ArchiveRecord_FSampleAccDAHistoND_swigregister
	ArchiveRecord_FSampleAccDAHistoND_swigregister(ArchiveRecord_FSampleAccDAHistoND)

	class Ref_FSampleAccDAHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_FSampleAccDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_FSampleAccDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_FSampleAccDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'FSampleAccDAHistoND') -> "void":
	return _npstat.Ref_FSampleAccDAHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::FloatSampleAccumulator,npstat::DualHistoAxis > *":
	return _npstat.Ref_FSampleAccDAHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::FloatSampleAccumulator,npstat::DualHistoAxis >":
	return _npstat.Ref_FSampleAccDAHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_FSampleAccDAHistoND
	__del__ = lambda self: None
	Ref_FSampleAccDAHistoND_swigregister = _npstat.Ref_FSampleAccDAHistoND_swigregister
	Ref_FSampleAccDAHistoND_swigregister(Ref_FSampleAccDAHistoND)

	class ArchiveRecord_DSampleAccHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DSampleAccHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DSampleAccHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DSampleAccHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DSampleAccHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DSampleAccHistoND
	__del__ = lambda self: None
	ArchiveRecord_DSampleAccHistoND_swigregister = _npstat.ArchiveRecord_DSampleAccHistoND_swigregister
	ArchiveRecord_DSampleAccHistoND_swigregister(ArchiveRecord_DSampleAccHistoND)

	class Ref_DSampleAccHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DSampleAccHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DSampleAccHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DSampleAccHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DSampleAccHistoND') -> "void":
	return _npstat.Ref_DSampleAccHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::HistoAxis > *":
	return _npstat.Ref_DSampleAccHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::HistoAxis >":
	return _npstat.Ref_DSampleAccHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DSampleAccHistoND
	__del__ = lambda self: None
	Ref_DSampleAccHistoND_swigregister = _npstat.Ref_DSampleAccHistoND_swigregister
	Ref_DSampleAccHistoND_swigregister(Ref_DSampleAccHistoND)

	class ArchiveRecord_DSampleAccNUHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DSampleAccNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DSampleAccNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DSampleAccNUHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DSampleAccNUHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DSampleAccNUHistoND
	__del__ = lambda self: None
	ArchiveRecord_DSampleAccNUHistoND_swigregister = _npstat.ArchiveRecord_DSampleAccNUHistoND_swigregister
	ArchiveRecord_DSampleAccNUHistoND_swigregister(ArchiveRecord_DSampleAccNUHistoND)

	class Ref_DSampleAccNUHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DSampleAccNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DSampleAccNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DSampleAccNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DSampleAccNUHistoND') -> "void":
	return _npstat.Ref_DSampleAccNUHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::NUHistoAxis > *":
	return _npstat.Ref_DSampleAccNUHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::NUHistoAxis >":
	return _npstat.Ref_DSampleAccNUHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DSampleAccNUHistoND
	__del__ = lambda self: None
	Ref_DSampleAccNUHistoND_swigregister = _npstat.Ref_DSampleAccNUHistoND_swigregister
	Ref_DSampleAccNUHistoND_swigregister(Ref_DSampleAccNUHistoND)

	class ArchiveRecord_DSampleAccDAHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DSampleAccDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DSampleAccDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DSampleAccDAHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DSampleAccDAHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DSampleAccDAHistoND
	__del__ = lambda self: None
	ArchiveRecord_DSampleAccDAHistoND_swigregister = _npstat.ArchiveRecord_DSampleAccDAHistoND_swigregister
	ArchiveRecord_DSampleAccDAHistoND_swigregister(ArchiveRecord_DSampleAccDAHistoND)

	class Ref_DSampleAccDAHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DSampleAccDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DSampleAccDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DSampleAccDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DSampleAccDAHistoND') -> "void":
	return _npstat.Ref_DSampleAccDAHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::DualHistoAxis > *":
	return _npstat.Ref_DSampleAccDAHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::DualHistoAxis >":
	return _npstat.Ref_DSampleAccDAHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DSampleAccDAHistoND
	__del__ = lambda self: None
	Ref_DSampleAccDAHistoND_swigregister = _npstat.Ref_DSampleAccDAHistoND_swigregister
	Ref_DSampleAccDAHistoND_swigregister(Ref_DSampleAccDAHistoND)

	class ArchiveRecord_DWSampleAccHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DWSampleAccHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DWSampleAccHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DWSampleAccHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DWSampleAccHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DWSampleAccHistoND
	__del__ = lambda self: None
	ArchiveRecord_DWSampleAccHistoND_swigregister = _npstat.ArchiveRecord_DWSampleAccHistoND_swigregister
	ArchiveRecord_DWSampleAccHistoND_swigregister(ArchiveRecord_DWSampleAccHistoND)

	class Ref_DWSampleAccHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DWSampleAccHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DWSampleAccHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DWSampleAccHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DWSampleAccHistoND') -> "void":
	return _npstat.Ref_DWSampleAccHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::HistoAxis > *":
	return _npstat.Ref_DWSampleAccHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::HistoAxis >":
	return _npstat.Ref_DWSampleAccHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DWSampleAccHistoND
	__del__ = lambda self: None
	Ref_DWSampleAccHistoND_swigregister = _npstat.Ref_DWSampleAccHistoND_swigregister
	Ref_DWSampleAccHistoND_swigregister(Ref_DWSampleAccHistoND)

	class ArchiveRecord_DWSampleAccNUHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DWSampleAccNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DWSampleAccNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DWSampleAccNUHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DWSampleAccNUHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DWSampleAccNUHistoND
	__del__ = lambda self: None
	ArchiveRecord_DWSampleAccNUHistoND_swigregister = _npstat.ArchiveRecord_DWSampleAccNUHistoND_swigregister
	ArchiveRecord_DWSampleAccNUHistoND_swigregister(ArchiveRecord_DWSampleAccNUHistoND)

	class Ref_DWSampleAccNUHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DWSampleAccNUHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DWSampleAccNUHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DWSampleAccNUHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DWSampleAccNUHistoND') -> "void":
	return _npstat.Ref_DWSampleAccNUHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::NUHistoAxis > *":
	return _npstat.Ref_DWSampleAccNUHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::NUHistoAxis >":
	return _npstat.Ref_DWSampleAccNUHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DWSampleAccNUHistoND
	__del__ = lambda self: None
	Ref_DWSampleAccNUHistoND_swigregister = _npstat.Ref_DWSampleAccNUHistoND_swigregister
	Ref_DWSampleAccNUHistoND_swigregister(Ref_DWSampleAccNUHistoND)

	class ArchiveRecord_DWSampleAccDAHistoND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DWSampleAccDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DWSampleAccDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DWSampleAccDAHistoND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DWSampleAccDAHistoND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DWSampleAccDAHistoND
	__del__ = lambda self: None
	ArchiveRecord_DWSampleAccDAHistoND_swigregister = _npstat.ArchiveRecord_DWSampleAccDAHistoND_swigregister
	ArchiveRecord_DWSampleAccDAHistoND_swigregister(ArchiveRecord_DWSampleAccDAHistoND)

	class Ref_DWSampleAccDAHistoND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DWSampleAccDAHistoND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DWSampleAccDAHistoND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DWSampleAccDAHistoND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DWSampleAccDAHistoND') -> "void":
	return _npstat.Ref_DWSampleAccDAHistoND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::DualHistoAxis > *":
	return _npstat.Ref_DWSampleAccDAHistoND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::DualHistoAxis >":
	return _npstat.Ref_DWSampleAccDAHistoND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DWSampleAccDAHistoND
	__del__ = lambda self: None
	Ref_DWSampleAccDAHistoND_swigregister = _npstat.Ref_DWSampleAccDAHistoND_swigregister
	Ref_DWSampleAccDAHistoND_swigregister(Ref_DWSampleAccDAHistoND)

	class HistoNDCdf(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, HistoNDCdf, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, HistoNDCdf, name)
	__repr__ = _swig_repr

	def dim(self) -> "unsigned int":
	return _npstat.HistoNDCdf_dim(self)

	def boundingBox(self) -> "npstat::BoxND< double >":
	return _npstat.HistoNDCdf_boundingBox(self)

	def cdf(self, x: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.HistoNDCdf_cdf(self, x, dim)

	def boxCoverage(self, box: 'DoubleBoxND') -> "double":
	return _npstat.HistoNDCdf_boxCoverage(self, box)

	def coveringBox(self, coveredFraction: 'double', boxCenter: 'double const *', dimCenter: 'unsigned int', coverBox: 'DoubleBoxND') -> "void":
	return _npstat.HistoNDCdf_coveringBox(self, coveredFraction, boxCenter, dimCenter, coverBox)

	def __init__(self, *args):
	this = _npstat.new_HistoNDCdf(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_HistoNDCdf
	__del__ = lambda self: None
	HistoNDCdf_swigregister = _npstat.HistoNDCdf_swigregister
	HistoNDCdf_swigregister(HistoNDCdf)

	class Int0NtHistoFill(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, Int0NtHistoFill, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, Int0NtHistoFill, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Int0NtHistoFill(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	if _newclass:
	callsFillC = staticmethod(_npstat.Int0NtHistoFill_callsFillC)
	else:
	callsFillC = _npstat.Int0NtHistoFill_callsFillC
	if _newclass:
	histoClassname = staticmethod(_npstat.Int0NtHistoFill_histoClassname)
	else:
	histoClassname = _npstat.Int0NtHistoFill_histoClassname
	__swig_destroy__ = _npstat.delete_Int0NtHistoFill
	__del__ = lambda self: None
	Int0NtHistoFill_swigregister = _npstat.Int0NtHistoFill_swigregister
	Int0NtHistoFill_swigregister(Int0NtHistoFill)

	def Int0NtHistoFill_callsFillC() -> "bool":
	return _npstat.Int0NtHistoFill_callsFillC()
	Int0NtHistoFill_callsFillC = _npstat.Int0NtHistoFill_callsFillC

	def Int0NtHistoFill_histoClassname() -> "char const *":
	return _npstat.Int0NtHistoFill_histoClassname()
	Int0NtHistoFill_histoClassname = _npstat.Int0NtHistoFill_histoClassname

	class LLong0NtHistoFill(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLong0NtHistoFill, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLong0NtHistoFill, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_LLong0NtHistoFill(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	if _newclass:
	callsFillC = staticmethod(_npstat.LLong0NtHistoFill_callsFillC)
	else:
	callsFillC = _npstat.LLong0NtHistoFill_callsFillC
	if _newclass:
	histoClassname = staticmethod(_npstat.LLong0NtHistoFill_histoClassname)
	else:
	histoClassname = _npstat.LLong0NtHistoFill_histoClassname
	__swig_destroy__ = _npstat.delete_LLong0NtHistoFill
	__del__ = lambda self: None
	LLong0NtHistoFill_swigregister = _npstat.LLong0NtHistoFill_swigregister
	LLong0NtHistoFill_swigregister(LLong0NtHistoFill)

	def LLong0NtHistoFill_callsFillC() -> "bool":
	return _npstat.LLong0NtHistoFill_callsFillC()
	LLong0NtHistoFill_callsFillC = _npstat.LLong0NtHistoFill_callsFillC

	def LLong0NtHistoFill_histoClassname() -> "char const *":
	return _npstat.LLong0NtHistoFill_histoClassname()
	LLong0NtHistoFill_histoClassname = _npstat.LLong0NtHistoFill_histoClassname

	class Float0NtHistoFill(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, Float0NtHistoFill, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, Float0NtHistoFill, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Float0NtHistoFill(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	if _newclass:
	callsFillC = staticmethod(_npstat.Float0NtHistoFill_callsFillC)
	else:
	callsFillC = _npstat.Float0NtHistoFill_callsFillC
	if _newclass:
	histoClassname = staticmethod(_npstat.Float0NtHistoFill_histoClassname)
	else:
	histoClassname = _npstat.Float0NtHistoFill_histoClassname
	__swig_destroy__ = _npstat.delete_Float0NtHistoFill
	__del__ = lambda self: None
	Float0NtHistoFill_swigregister = _npstat.Float0NtHistoFill_swigregister
	Float0NtHistoFill_swigregister(Float0NtHistoFill)

	def Float0NtHistoFill_callsFillC() -> "bool":
	return _npstat.Float0NtHistoFill_callsFillC()
	Float0NtHistoFill_callsFillC = _npstat.Float0NtHistoFill_callsFillC

	def Float0NtHistoFill_histoClassname() -> "char const *":
	return _npstat.Float0NtHistoFill_histoClassname()
	Float0NtHistoFill_histoClassname = _npstat.Float0NtHistoFill_histoClassname

	class Double0NtHistoFill(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, Double0NtHistoFill, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, Double0NtHistoFill, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Double0NtHistoFill(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	if _newclass:
	callsFillC = staticmethod(_npstat.Double0NtHistoFill_callsFillC)
	else:
	callsFillC = _npstat.Double0NtHistoFill_callsFillC
	if _newclass:
	histoClassname = staticmethod(_npstat.Double0NtHistoFill_histoClassname)
	else:
	histoClassname = _npstat.Double0NtHistoFill_histoClassname
	__swig_destroy__ = _npstat.delete_Double0NtHistoFill
	__del__ = lambda self: None
	Double0NtHistoFill_swigregister = _npstat.Double0NtHistoFill_swigregister
	Double0NtHistoFill_swigregister(Double0NtHistoFill)

	def Double0NtHistoFill_callsFillC() -> "bool":
	return _npstat.Double0NtHistoFill_callsFillC()
	Double0NtHistoFill_callsFillC = _npstat.Double0NtHistoFill_callsFillC

	def Double0NtHistoFill_histoClassname() -> "char const *":
	return _npstat.Double0NtHistoFill_histoClassname()
	Double0NtHistoFill_histoClassname = _npstat.Double0NtHistoFill_histoClassname

	class Int1NtHistoFill(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, Int1NtHistoFill, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, Int1NtHistoFill, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Int1NtHistoFill(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	if _newclass:
	callsFillC = staticmethod(_npstat.Int1NtHistoFill_callsFillC)
	else:
	callsFillC = _npstat.Int1NtHistoFill_callsFillC
	if _newclass:
	histoClassname = staticmethod(_npstat.Int1NtHistoFill_histoClassname)
	else:
	histoClassname = _npstat.Int1NtHistoFill_histoClassname
	__swig_destroy__ = _npstat.delete_Int1NtHistoFill
	__del__ = lambda self: None
	Int1NtHistoFill_swigregister = _npstat.Int1NtHistoFill_swigregister
	Int1NtHistoFill_swigregister(Int1NtHistoFill)

	def Int1NtHistoFill_callsFillC() -> "bool":
	return _npstat.Int1NtHistoFill_callsFillC()
	Int1NtHistoFill_callsFillC = _npstat.Int1NtHistoFill_callsFillC

	def Int1NtHistoFill_histoClassname() -> "char const *":
	return _npstat.Int1NtHistoFill_histoClassname()
	Int1NtHistoFill_histoClassname = _npstat.Int1NtHistoFill_histoClassname

	class LLong1NtHistoFill(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLong1NtHistoFill, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLong1NtHistoFill, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_LLong1NtHistoFill(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	if _newclass:
	callsFillC = staticmethod(_npstat.LLong1NtHistoFill_callsFillC)
	else:
	callsFillC = _npstat.LLong1NtHistoFill_callsFillC
	if _newclass:
	histoClassname = staticmethod(_npstat.LLong1NtHistoFill_histoClassname)
	else:
	histoClassname = _npstat.LLong1NtHistoFill_histoClassname
	__swig_destroy__ = _npstat.delete_LLong1NtHistoFill
	__del__ = lambda self: None
	LLong1NtHistoFill_swigregister = _npstat.LLong1NtHistoFill_swigregister
	LLong1NtHistoFill_swigregister(LLong1NtHistoFill)

	def LLong1NtHistoFill_callsFillC() -> "bool":
	return _npstat.LLong1NtHistoFill_callsFillC()
	LLong1NtHistoFill_callsFillC = _npstat.LLong1NtHistoFill_callsFillC

	def LLong1NtHistoFill_histoClassname() -> "char const *":
	return _npstat.LLong1NtHistoFill_histoClassname()
	LLong1NtHistoFill_histoClassname = _npstat.LLong1NtHistoFill_histoClassname

	class Float1NtHistoFill(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, Float1NtHistoFill, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, Float1NtHistoFill, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Float1NtHistoFill(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	if _newclass:
	callsFillC = staticmethod(_npstat.Float1NtHistoFill_callsFillC)
	else:
	callsFillC = _npstat.Float1NtHistoFill_callsFillC
	if _newclass:
	histoClassname = staticmethod(_npstat.Float1NtHistoFill_histoClassname)
	else:
	histoClassname = _npstat.Float1NtHistoFill_histoClassname
	__swig_destroy__ = _npstat.delete_Float1NtHistoFill
	__del__ = lambda self: None
	Float1NtHistoFill_swigregister = _npstat.Float1NtHistoFill_swigregister
	Float1NtHistoFill_swigregister(Float1NtHistoFill)

	def Float1NtHistoFill_callsFillC() -> "bool":
	return _npstat.Float1NtHistoFill_callsFillC()
	Float1NtHistoFill_callsFillC = _npstat.Float1NtHistoFill_callsFillC

	def Float1NtHistoFill_histoClassname() -> "char const *":
	return _npstat.Float1NtHistoFill_histoClassname()
	Float1NtHistoFill_histoClassname = _npstat.Float1NtHistoFill_histoClassname

	class Double1NtHistoFill(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, Double1NtHistoFill, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, Double1NtHistoFill, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Double1NtHistoFill(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	if _newclass:
	callsFillC = staticmethod(_npstat.Double1NtHistoFill_callsFillC)
	else:
	callsFillC = _npstat.Double1NtHistoFill_callsFillC
	if _newclass:
	histoClassname = staticmethod(_npstat.Double1NtHistoFill_histoClassname)
	else:
	histoClassname = _npstat.Double1NtHistoFill_histoClassname
	__swig_destroy__ = _npstat.delete_Double1NtHistoFill
	__del__ = lambda self: None
	Double1NtHistoFill_swigregister = _npstat.Double1NtHistoFill_swigregister
	Double1NtHistoFill_swigregister(Double1NtHistoFill)

	def Double1NtHistoFill_callsFillC() -> "bool":
	return _npstat.Double1NtHistoFill_callsFillC()
	Double1NtHistoFill_callsFillC = _npstat.Double1NtHistoFill_callsFillC

	def Double1NtHistoFill_histoClassname() -> "char const *":
	return _npstat.Double1NtHistoFill_histoClassname()
	Double1NtHistoFill_histoClassname = _npstat.Double1NtHistoFill_histoClassname

	class Int0NUNtHistoFill(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, Int0NUNtHistoFill, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, Int0NUNtHistoFill, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Int0NUNtHistoFill(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	if _newclass:
	callsFillC = staticmethod(_npstat.Int0NUNtHistoFill_callsFillC)
	else:
	callsFillC = _npstat.Int0NUNtHistoFill_callsFillC
	if _newclass:
	histoClassname = staticmethod(_npstat.Int0NUNtHistoFill_histoClassname)
	else:
	histoClassname = _npstat.Int0NUNtHistoFill_histoClassname
	__swig_destroy__ = _npstat.delete_Int0NUNtHistoFill
	__del__ = lambda self: None
	Int0NUNtHistoFill_swigregister = _npstat.Int0NUNtHistoFill_swigregister
	Int0NUNtHistoFill_swigregister(Int0NUNtHistoFill)

	def Int0NUNtHistoFill_callsFillC() -> "bool":
	return _npstat.Int0NUNtHistoFill_callsFillC()
	Int0NUNtHistoFill_callsFillC = _npstat.Int0NUNtHistoFill_callsFillC

	def Int0NUNtHistoFill_histoClassname() -> "char const *":
	return _npstat.Int0NUNtHistoFill_histoClassname()
	Int0NUNtHistoFill_histoClassname = _npstat.Int0NUNtHistoFill_histoClassname

	class LLong0NUNtHistoFill(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLong0NUNtHistoFill, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLong0NUNtHistoFill, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_LLong0NUNtHistoFill(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	if _newclass:
	callsFillC = staticmethod(_npstat.LLong0NUNtHistoFill_callsFillC)
	else:
	callsFillC = _npstat.LLong0NUNtHistoFill_callsFillC
	if _newclass:
	histoClassname = staticmethod(_npstat.LLong0NUNtHistoFill_histoClassname)
	else:
	histoClassname = _npstat.LLong0NUNtHistoFill_histoClassname
	__swig_destroy__ = _npstat.delete_LLong0NUNtHistoFill
	__del__ = lambda self: None
	LLong0NUNtHistoFill_swigregister = _npstat.LLong0NUNtHistoFill_swigregister
	LLong0NUNtHistoFill_swigregister(LLong0NUNtHistoFill)

	def LLong0NUNtHistoFill_callsFillC() -> "bool":
	return _npstat.LLong0NUNtHistoFill_callsFillC()
	LLong0NUNtHistoFill_callsFillC = _npstat.LLong0NUNtHistoFill_callsFillC

	def LLong0NUNtHistoFill_histoClassname() -> "char const *":
	return _npstat.LLong0NUNtHistoFill_histoClassname()
	LLong0NUNtHistoFill_histoClassname = _npstat.LLong0NUNtHistoFill_histoClassname

	class Float0NUNtHistoFill(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, Float0NUNtHistoFill, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, Float0NUNtHistoFill, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Float0NUNtHistoFill(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	if _newclass:
	callsFillC = staticmethod(_npstat.Float0NUNtHistoFill_callsFillC)
	else:
	callsFillC = _npstat.Float0NUNtHistoFill_callsFillC
	if _newclass:
	histoClassname = staticmethod(_npstat.Float0NUNtHistoFill_histoClassname)
	else:
	histoClassname = _npstat.Float0NUNtHistoFill_histoClassname
	__swig_destroy__ = _npstat.delete_Float0NUNtHistoFill
	__del__ = lambda self: None
	Float0NUNtHistoFill_swigregister = _npstat.Float0NUNtHistoFill_swigregister
	Float0NUNtHistoFill_swigregister(Float0NUNtHistoFill)

	def Float0NUNtHistoFill_callsFillC() -> "bool":
	return _npstat.Float0NUNtHistoFill_callsFillC()
	Float0NUNtHistoFill_callsFillC = _npstat.Float0NUNtHistoFill_callsFillC

	def Float0NUNtHistoFill_histoClassname() -> "char const *":
	return _npstat.Float0NUNtHistoFill_histoClassname()
	Float0NUNtHistoFill_histoClassname = _npstat.Float0NUNtHistoFill_histoClassname

	class Double0NUNtHistoFill(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, Double0NUNtHistoFill, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, Double0NUNtHistoFill, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Double0NUNtHistoFill(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	if _newclass:
	callsFillC = staticmethod(_npstat.Double0NUNtHistoFill_callsFillC)
	else:
	callsFillC = _npstat.Double0NUNtHistoFill_callsFillC
	if _newclass:
	histoClassname = staticmethod(_npstat.Double0NUNtHistoFill_histoClassname)
	else:
	histoClassname = _npstat.Double0NUNtHistoFill_histoClassname
	__swig_destroy__ = _npstat.delete_Double0NUNtHistoFill
	__del__ = lambda self: None
	Double0NUNtHistoFill_swigregister = _npstat.Double0NUNtHistoFill_swigregister
	Double0NUNtHistoFill_swigregister(Double0NUNtHistoFill)

	def Double0NUNtHistoFill_callsFillC() -> "bool":
	return _npstat.Double0NUNtHistoFill_callsFillC()
	Double0NUNtHistoFill_callsFillC = _npstat.Double0NUNtHistoFill_callsFillC

	def Double0NUNtHistoFill_histoClassname() -> "char const *":
	return _npstat.Double0NUNtHistoFill_histoClassname()
	Double0NUNtHistoFill_histoClassname = _npstat.Double0NUNtHistoFill_histoClassname

	class IntNtNtupleFill(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntNtNtupleFill, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntNtNtupleFill, name)
	__repr__ = _swig_repr

	def __init__(self, destination: 'IntAbsNtuple', columnMap: 'ULongVector'):
	this = _npstat.new_IntNtNtupleFill(destination, columnMap)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_IntNtNtupleFill
	__del__ = lambda self: None
	IntNtNtupleFill_swigregister = _npstat.IntNtNtupleFill_swigregister
	IntNtNtupleFill_swigregister(IntNtNtupleFill)

	class LLongNtNtupleFill(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongNtNtupleFill, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongNtNtupleFill, name)
	__repr__ = _swig_repr

	def __init__(self, destination: 'LLongAbsNtuple', columnMap: 'ULongVector'):
	this = _npstat.new_LLongNtNtupleFill(destination, columnMap)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_LLongNtNtupleFill
	__del__ = lambda self: None
	LLongNtNtupleFill_swigregister = _npstat.LLongNtNtupleFill_swigregister
	LLongNtNtupleFill_swigregister(LLongNtNtupleFill)

	class UCharNtNtupleFill(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharNtNtupleFill, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharNtNtupleFill, name)
	__repr__ = _swig_repr

	def __init__(self, destination: 'UCharAbsNtuple', columnMap: 'ULongVector'):
	this = _npstat.new_UCharNtNtupleFill(destination, columnMap)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UCharNtNtupleFill
	__del__ = lambda self: None
	UCharNtNtupleFill_swigregister = _npstat.UCharNtNtupleFill_swigregister
	UCharNtNtupleFill_swigregister(UCharNtNtupleFill)

	class FloatNtNtupleFill(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatNtNtupleFill, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatNtNtupleFill, name)
	__repr__ = _swig_repr

	def __init__(self, destination: 'FloatAbsNtuple', columnMap: 'ULongVector'):
	this = _npstat.new_FloatNtNtupleFill(destination, columnMap)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatNtNtupleFill
	__del__ = lambda self: None
	FloatNtNtupleFill_swigregister = _npstat.FloatNtNtupleFill_swigregister
	FloatNtNtupleFill_swigregister(FloatNtNtupleFill)

	class DoubleNtNtupleFill(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleNtNtupleFill, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleNtNtupleFill, name)
	__repr__ = _swig_repr

	def __init__(self, destination: 'DoubleAbsNtuple', columnMap: 'ULongVector'):
	this = _npstat.new_DoubleNtNtupleFill(destination, columnMap)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleNtNtupleFill
	__del__ = lambda self: None
	DoubleNtNtupleFill_swigregister = _npstat.DoubleNtNtupleFill_swigregister
	DoubleNtNtupleFill_swigregister(DoubleNtNtupleFill)


	def make_NtNtupleFill(*args) -> "npstat::NtNtupleFill< npstat::AbsNtuple< double > >":
	return _npstat.make_NtNtupleFill(*args)
	make_NtNtupleFill = _npstat.make_NtNtupleFill
	class UCharNtRectangularCut(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharNtRectangularCut, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharNtRectangularCut, name)
	__repr__ = _swig_repr

	def invert(self) -> "void":
	return _npstat.UCharNtRectangularCut_invert(self)

	def dim(self) -> "unsigned long":
	return _npstat.UCharNtRectangularCut_dim(self)

	def cutColumn(self, cutNumber: 'unsigned long const') -> "unsigned long":
	return _npstat.UCharNtRectangularCut_cutColumn(self, cutNumber)

	def cutInterval(self, cutNumber: 'unsigned long', minValue: 'unsigned char ', maxValue: 'unsigned char ') -> "void":
	return _npstat.UCharNtRectangularCut_cutInterval(self, cutNumber, minValue, maxValue)

	def isInverted(self, cutNumber: 'unsigned long') -> "bool":
	return _npstat.UCharNtRectangularCut_isInverted(self, cutNumber)

	def nUniqueColumns(self) -> "unsigned long":
	return _npstat.UCharNtRectangularCut_nUniqueColumns(self)

	def ntupleColumns(self) -> "std::vector< unsigned long,std::allocator< unsigned long > >":
	return _npstat.UCharNtRectangularCut_ntupleColumns(self)

	def acceptedBox(self) -> "npstat::BoxND< unsigned char >":
	return _npstat.UCharNtRectangularCut_acceptedBox(self)

	def __call__(self, row: 'unsigned char const *', nCols: 'unsigned long') -> "bool":
	return _npstat.UCharNtRectangularCut___call__(self, row, nCols)

	def __eq__(self, r: 'UCharNtRectangularCut') -> "bool":
	return _npstat.UCharNtRectangularCut___eq__(self, r)

	def __ne__(self, r: 'UCharNtRectangularCut') -> "bool":
	return _npstat.UCharNtRectangularCut___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.UCharNtRectangularCut_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.UCharNtRectangularCut_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.UCharNtRectangularCut_classname)
	else:
	classname = _npstat.UCharNtRectangularCut_classname
	if _newclass:
	version = staticmethod(_npstat.UCharNtRectangularCut_version)
	else:
	version = _npstat.UCharNtRectangularCut_version
	if _newclass:
	restore = staticmethod(_npstat.UCharNtRectangularCut_restore)
	else:
	restore = _npstat.UCharNtRectangularCut_restore

	def addCut(self, *args) -> "void":
	return _npstat.UCharNtRectangularCut_addCut(self, *args)

	def __init__(self, *args):
	this = _npstat.new_UCharNtRectangularCut(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UCharNtRectangularCut
	__del__ = lambda self: None
	UCharNtRectangularCut_swigregister = _npstat.UCharNtRectangularCut_swigregister
	UCharNtRectangularCut_swigregister(UCharNtRectangularCut)

	def UCharNtRectangularCut_classname() -> "char const *":
	return _npstat.UCharNtRectangularCut_classname()
	UCharNtRectangularCut_classname = _npstat.UCharNtRectangularCut_classname

	def UCharNtRectangularCut_version() -> "unsigned int":
	return _npstat.UCharNtRectangularCut_version()
	UCharNtRectangularCut_version = _npstat.UCharNtRectangularCut_version

	def UCharNtRectangularCut_restore(id: 'ClassId', arg3: 'istream', cut: 'UCharNtRectangularCut') -> "void":
	return _npstat.UCharNtRectangularCut_restore(id, arg3, cut)
	UCharNtRectangularCut_restore = _npstat.UCharNtRectangularCut_restore

	class IntNtRectangularCut(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntNtRectangularCut, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntNtRectangularCut, name)
	__repr__ = _swig_repr

	def invert(self) -> "void":
	return _npstat.IntNtRectangularCut_invert(self)

	def dim(self) -> "unsigned long":
	return _npstat.IntNtRectangularCut_dim(self)

	def cutColumn(self, cutNumber: 'unsigned long const') -> "unsigned long":
	return _npstat.IntNtRectangularCut_cutColumn(self, cutNumber)

	def cutInterval(self, cutNumber: 'unsigned long', minValue: 'int ', maxValue: 'int ') -> "void":
	return _npstat.IntNtRectangularCut_cutInterval(self, cutNumber, minValue, maxValue)

	def isInverted(self, cutNumber: 'unsigned long') -> "bool":
	return _npstat.IntNtRectangularCut_isInverted(self, cutNumber)

	def nUniqueColumns(self) -> "unsigned long":
	return _npstat.IntNtRectangularCut_nUniqueColumns(self)

	def ntupleColumns(self) -> "std::vector< unsigned long,std::allocator< unsigned long > >":
	return _npstat.IntNtRectangularCut_ntupleColumns(self)

	def acceptedBox(self) -> "npstat::BoxND< int >":
	return _npstat.IntNtRectangularCut_acceptedBox(self)

	def __call__(self, row: 'int const *', nCols: 'unsigned long') -> "bool":
	return _npstat.IntNtRectangularCut___call__(self, row, nCols)

	def __eq__(self, r: 'IntNtRectangularCut') -> "bool":
	return _npstat.IntNtRectangularCut___eq__(self, r)

	def __ne__(self, r: 'IntNtRectangularCut') -> "bool":
	return _npstat.IntNtRectangularCut___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.IntNtRectangularCut_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.IntNtRectangularCut_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.IntNtRectangularCut_classname)
	else:
	classname = _npstat.IntNtRectangularCut_classname
	if _newclass:
	version = staticmethod(_npstat.IntNtRectangularCut_version)
	else:
	version = _npstat.IntNtRectangularCut_version
	if _newclass:
	restore = staticmethod(_npstat.IntNtRectangularCut_restore)
	else:
	restore = _npstat.IntNtRectangularCut_restore

	def addCut(self, *args) -> "void":
	return _npstat.IntNtRectangularCut_addCut(self, *args)

	def __init__(self, *args):
	this = _npstat.new_IntNtRectangularCut(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_IntNtRectangularCut
	__del__ = lambda self: None
	IntNtRectangularCut_swigregister = _npstat.IntNtRectangularCut_swigregister
	IntNtRectangularCut_swigregister(IntNtRectangularCut)

	def IntNtRectangularCut_classname() -> "char const *":
	return _npstat.IntNtRectangularCut_classname()
	IntNtRectangularCut_classname = _npstat.IntNtRectangularCut_classname

	def IntNtRectangularCut_version() -> "unsigned int":
	return _npstat.IntNtRectangularCut_version()
	IntNtRectangularCut_version = _npstat.IntNtRectangularCut_version

	def IntNtRectangularCut_restore(id: 'ClassId', arg3: 'istream', cut: 'IntNtRectangularCut') -> "void":
	return _npstat.IntNtRectangularCut_restore(id, arg3, cut)
	IntNtRectangularCut_restore = _npstat.IntNtRectangularCut_restore

	class LLongNtRectangularCut(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongNtRectangularCut, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongNtRectangularCut, name)
	__repr__ = _swig_repr

	def invert(self) -> "void":
	return _npstat.LLongNtRectangularCut_invert(self)

	def dim(self) -> "unsigned long":
	return _npstat.LLongNtRectangularCut_dim(self)

	def cutColumn(self, cutNumber: 'unsigned long const') -> "unsigned long":
	return _npstat.LLongNtRectangularCut_cutColumn(self, cutNumber)

	def cutInterval(self, cutNumber: 'unsigned long', minValue: 'long long ', maxValue: 'long long ') -> "void":
	return _npstat.LLongNtRectangularCut_cutInterval(self, cutNumber, minValue, maxValue)

	def isInverted(self, cutNumber: 'unsigned long') -> "bool":
	return _npstat.LLongNtRectangularCut_isInverted(self, cutNumber)

	def nUniqueColumns(self) -> "unsigned long":
	return _npstat.LLongNtRectangularCut_nUniqueColumns(self)

	def ntupleColumns(self) -> "std::vector< unsigned long,std::allocator< unsigned long > >":
	return _npstat.LLongNtRectangularCut_ntupleColumns(self)

	def acceptedBox(self) -> "npstat::BoxND< long long >":
	return _npstat.LLongNtRectangularCut_acceptedBox(self)

	def __call__(self, row: 'long long const *', nCols: 'unsigned long') -> "bool":
	return _npstat.LLongNtRectangularCut___call__(self, row, nCols)

	def __eq__(self, r: 'LLongNtRectangularCut') -> "bool":
	return _npstat.LLongNtRectangularCut___eq__(self, r)

	def __ne__(self, r: 'LLongNtRectangularCut') -> "bool":
	return _npstat.LLongNtRectangularCut___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.LLongNtRectangularCut_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.LLongNtRectangularCut_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.LLongNtRectangularCut_classname)
	else:
	classname = _npstat.LLongNtRectangularCut_classname
	if _newclass:
	version = staticmethod(_npstat.LLongNtRectangularCut_version)
	else:
	version = _npstat.LLongNtRectangularCut_version
	if _newclass:
	restore = staticmethod(_npstat.LLongNtRectangularCut_restore)
	else:
	restore = _npstat.LLongNtRectangularCut_restore

	def addCut(self, *args) -> "void":
	return _npstat.LLongNtRectangularCut_addCut(self, *args)

	def __init__(self, *args):
	this = _npstat.new_LLongNtRectangularCut(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_LLongNtRectangularCut
	__del__ = lambda self: None
	LLongNtRectangularCut_swigregister = _npstat.LLongNtRectangularCut_swigregister
	LLongNtRectangularCut_swigregister(LLongNtRectangularCut)

	def LLongNtRectangularCut_classname() -> "char const *":
	return _npstat.LLongNtRectangularCut_classname()
	LLongNtRectangularCut_classname = _npstat.LLongNtRectangularCut_classname

	def LLongNtRectangularCut_version() -> "unsigned int":
	return _npstat.LLongNtRectangularCut_version()
	LLongNtRectangularCut_version = _npstat.LLongNtRectangularCut_version

	def LLongNtRectangularCut_restore(id: 'ClassId', arg3: 'istream', cut: 'LLongNtRectangularCut') -> "void":
	return _npstat.LLongNtRectangularCut_restore(id, arg3, cut)
	LLongNtRectangularCut_restore = _npstat.LLongNtRectangularCut_restore

	class FloatNtRectangularCut(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatNtRectangularCut, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatNtRectangularCut, name)
	__repr__ = _swig_repr

	def invert(self) -> "void":
	return _npstat.FloatNtRectangularCut_invert(self)

	def dim(self) -> "unsigned long":
	return _npstat.FloatNtRectangularCut_dim(self)

	def cutColumn(self, cutNumber: 'unsigned long const') -> "unsigned long":
	return _npstat.FloatNtRectangularCut_cutColumn(self, cutNumber)

	def cutInterval(self, cutNumber: 'unsigned long', minValue: 'float ', maxValue: 'float ') -> "void":
	return _npstat.FloatNtRectangularCut_cutInterval(self, cutNumber, minValue, maxValue)

	def isInverted(self, cutNumber: 'unsigned long') -> "bool":
	return _npstat.FloatNtRectangularCut_isInverted(self, cutNumber)

	def nUniqueColumns(self) -> "unsigned long":
	return _npstat.FloatNtRectangularCut_nUniqueColumns(self)

	def ntupleColumns(self) -> "std::vector< unsigned long,std::allocator< unsigned long > >":
	return _npstat.FloatNtRectangularCut_ntupleColumns(self)

	def acceptedBox(self) -> "npstat::BoxND< float >":
	return _npstat.FloatNtRectangularCut_acceptedBox(self)

	def __call__(self, row: 'float const *', nCols: 'unsigned long') -> "bool":
	return _npstat.FloatNtRectangularCut___call__(self, row, nCols)

	def __eq__(self, r: 'FloatNtRectangularCut') -> "bool":
	return _npstat.FloatNtRectangularCut___eq__(self, r)

	def __ne__(self, r: 'FloatNtRectangularCut') -> "bool":
	return _npstat.FloatNtRectangularCut___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatNtRectangularCut_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatNtRectangularCut_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatNtRectangularCut_classname)
	else:
	classname = _npstat.FloatNtRectangularCut_classname
	if _newclass:
	version = staticmethod(_npstat.FloatNtRectangularCut_version)
	else:
	version = _npstat.FloatNtRectangularCut_version
	if _newclass:
	restore = staticmethod(_npstat.FloatNtRectangularCut_restore)
	else:
	restore = _npstat.FloatNtRectangularCut_restore

	def addCut(self, *args) -> "void":
	return _npstat.FloatNtRectangularCut_addCut(self, *args)

	def __init__(self, *args):
	this = _npstat.new_FloatNtRectangularCut(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatNtRectangularCut
	__del__ = lambda self: None
	FloatNtRectangularCut_swigregister = _npstat.FloatNtRectangularCut_swigregister
	FloatNtRectangularCut_swigregister(FloatNtRectangularCut)

	def FloatNtRectangularCut_classname() -> "char const *":
	return _npstat.FloatNtRectangularCut_classname()
	FloatNtRectangularCut_classname = _npstat.FloatNtRectangularCut_classname

	def FloatNtRectangularCut_version() -> "unsigned int":
	return _npstat.FloatNtRectangularCut_version()
	FloatNtRectangularCut_version = _npstat.FloatNtRectangularCut_version

	def FloatNtRectangularCut_restore(id: 'ClassId', arg3: 'istream', cut: 'FloatNtRectangularCut') -> "void":
	return _npstat.FloatNtRectangularCut_restore(id, arg3, cut)
	FloatNtRectangularCut_restore = _npstat.FloatNtRectangularCut_restore

	class DoubleNtRectangularCut(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleNtRectangularCut, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleNtRectangularCut, name)
	__repr__ = _swig_repr

	def invert(self) -> "void":
	return _npstat.DoubleNtRectangularCut_invert(self)

	def dim(self) -> "unsigned long":
	return _npstat.DoubleNtRectangularCut_dim(self)

	def cutColumn(self, cutNumber: 'unsigned long const') -> "unsigned long":
	return _npstat.DoubleNtRectangularCut_cutColumn(self, cutNumber)

	def cutInterval(self, cutNumber: 'unsigned long', minValue: 'double ', maxValue: 'double ') -> "void":
	return _npstat.DoubleNtRectangularCut_cutInterval(self, cutNumber, minValue, maxValue)

	def isInverted(self, cutNumber: 'unsigned long') -> "bool":
	return _npstat.DoubleNtRectangularCut_isInverted(self, cutNumber)

	def nUniqueColumns(self) -> "unsigned long":
	return _npstat.DoubleNtRectangularCut_nUniqueColumns(self)

	def ntupleColumns(self) -> "std::vector< unsigned long,std::allocator< unsigned long > >":
	return _npstat.DoubleNtRectangularCut_ntupleColumns(self)

	def acceptedBox(self) -> "npstat::BoxND< double >":
	return _npstat.DoubleNtRectangularCut_acceptedBox(self)

	def __call__(self, row: 'double const *', nCols: 'unsigned long') -> "bool":
	return _npstat.DoubleNtRectangularCut___call__(self, row, nCols)

	def __eq__(self, r: 'DoubleNtRectangularCut') -> "bool":
	return _npstat.DoubleNtRectangularCut___eq__(self, r)

	def __ne__(self, r: 'DoubleNtRectangularCut') -> "bool":
	return _npstat.DoubleNtRectangularCut___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleNtRectangularCut_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleNtRectangularCut_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleNtRectangularCut_classname)
	else:
	classname = _npstat.DoubleNtRectangularCut_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleNtRectangularCut_version)
	else:
	version = _npstat.DoubleNtRectangularCut_version
	if _newclass:
	restore = staticmethod(_npstat.DoubleNtRectangularCut_restore)
	else:
	restore = _npstat.DoubleNtRectangularCut_restore

	def addCut(self, *args) -> "void":
	return _npstat.DoubleNtRectangularCut_addCut(self, *args)

	def __init__(self, *args):
	this = _npstat.new_DoubleNtRectangularCut(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleNtRectangularCut
	__del__ = lambda self: None
	DoubleNtRectangularCut_swigregister = _npstat.DoubleNtRectangularCut_swigregister
	DoubleNtRectangularCut_swigregister(DoubleNtRectangularCut)

	def DoubleNtRectangularCut_classname() -> "char const *":
	return _npstat.DoubleNtRectangularCut_classname()
	DoubleNtRectangularCut_classname = _npstat.DoubleNtRectangularCut_classname

	def DoubleNtRectangularCut_version() -> "unsigned int":
	return _npstat.DoubleNtRectangularCut_version()
	DoubleNtRectangularCut_version = _npstat.DoubleNtRectangularCut_version

	def DoubleNtRectangularCut_restore(id: 'ClassId', arg3: 'istream', cut: 'DoubleNtRectangularCut') -> "void":
	return _npstat.DoubleNtRectangularCut_restore(id, arg3, cut)
	DoubleNtRectangularCut_restore = _npstat.DoubleNtRectangularCut_restore


	def ntupleColumns(*args) -> "std::vector< std::string,std::allocator< std::string > >":
	return _npstat.ntupleColumns(*args)
	ntupleColumns = _npstat.ntupleColumns

	def simpleColumnNames(ncols: 'unsigned int') -> "std::vector< std::string,std::allocator< std::string > >":
	return _npstat.simpleColumnNames(ncols)
	simpleColumnNames = _npstat.simpleColumnNames
	class UCharAbsNtuple(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharAbsNtuple, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharAbsNtuple, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_UCharAbsNtuple
	__del__ = lambda self: None

	def title(self) -> "std::string const &":
	return _npstat.UCharAbsNtuple_title(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.UCharAbsNtuple_setTitle(self, newtitle)

	def nColumns(self) -> "unsigned long":
	return _npstat.UCharAbsNtuple_nColumns(self)

	def columnName(self, i: 'unsigned long const') -> "std::string const &":
	return _npstat.UCharAbsNtuple_columnName(self, i)

	def columnNames(self) -> "std::vector< std::string,std::allocator< std::string > > const &":
	return _npstat.UCharAbsNtuple_columnNames(self)

	def setColumnName(self, i: 'unsigned long', newname: 'char const *') -> "bool":
	return _npstat.UCharAbsNtuple_setColumnName(self, i, newname)

	def columnNumber(self, columnName: 'char const *') -> "unsigned long":
	return _npstat.UCharAbsNtuple_columnNumber(self, columnName)

	def validColumn(self, columnName: 'char const *') -> "unsigned long":
	return _npstat.UCharAbsNtuple_validColumn(self, columnName)

	def nRows(self) -> "unsigned long":
	return _npstat.UCharAbsNtuple_nRows(self)

	def length(self) -> "unsigned long":
	return _npstat.UCharAbsNtuple_length(self)

	def fill(self, *args) -> "void":
	return _npstat.UCharAbsNtuple_fill(self, *args)

	def __call__(self, r: 'unsigned long', c: 'unsigned long') -> "unsigned char":
	return _npstat.UCharAbsNtuple___call__(self, r, c)

	def at(self, r: 'unsigned long', c: 'unsigned long') -> "unsigned char":
	return _npstat.UCharAbsNtuple_at(self, r, c)

	def element(self, r: 'unsigned long', c: 'Column') -> "unsigned char":
	return _npstat.UCharAbsNtuple_element(self, r, c)

	def elementAt(self, r: 'unsigned long', c: 'Column') -> "unsigned char":
	return _npstat.UCharAbsNtuple_elementAt(self, r, c)

	def rowContents(self, row: 'unsigned long', buf: 'unsigned char *', lenBuf: 'unsigned long') -> "void":
	return _npstat.UCharAbsNtuple_rowContents(self, row, buf, lenBuf)

	def columnContents(self, c: 'Column', buf: 'unsigned char *', lenBuf: 'unsigned long') -> "void":
	return _npstat.UCharAbsNtuple_columnContents(self, c, buf, lenBuf)

	def clear(self) -> "void":
	return _npstat.UCharAbsNtuple_clear(self)

	def row_begin(self, rowNumber: 'unsigned long') -> "npstat::AbsNtuple< unsigned char >::row_iterator":
	return _npstat.UCharAbsNtuple_row_begin(self, rowNumber)

	def row_end(self) -> "npstat::AbsNtuple< unsigned char >::row_iterator":
	return _npstat.UCharAbsNtuple_row_end(self)

	def column_begin(self, column: 'Column') -> "npstat::AbsNtuple< unsigned char >::column_iterator":
	return _npstat.UCharAbsNtuple_column_begin(self, column)

	def column_end(self) -> "npstat::AbsNtuple< unsigned char >::column_iterator":
	return _npstat.UCharAbsNtuple_column_end(self)

	def columnIndices(self, *args) -> "std::vector< unsigned long,std::allocator< unsigned long > >":
	return _npstat.UCharAbsNtuple_columnIndices(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.UCharAbsNtuple_classId(self)

	def __eq__(self, r: 'UCharAbsNtuple') -> "bool":
	return _npstat.UCharAbsNtuple___eq__(self, r)

	def __ne__(self, r: 'UCharAbsNtuple') -> "bool":
	return _npstat.UCharAbsNtuple___ne__(self, r)

	def append(self, other: 'UCharAbsNtuple') -> "void":
	return _npstat.UCharAbsNtuple_append(self, other)

	def columnArray(self, args) -> "PyObject ":
	return _npstat.UCharAbsNtuple_columnArray(self, *args)

	def rowArray(self, row: 'unsigned long') -> "PyObject *":
	return _npstat.UCharAbsNtuple_rowArray(self, row)

	def cycleOverRows(self, *args) -> "void":
	return _npstat.UCharAbsNtuple_cycleOverRows(self, *args)

	def cutCycleOverRows(self, *args) -> "unsigned long":
	return _npstat.UCharAbsNtuple_cutCycleOverRows(self, *args)
	UCharAbsNtuple_swigregister = _npstat.UCharAbsNtuple_swigregister
	UCharAbsNtuple_swigregister(UCharAbsNtuple)

	class IntAbsNtuple(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntAbsNtuple, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntAbsNtuple, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_IntAbsNtuple
	__del__ = lambda self: None

	def title(self) -> "std::string const &":
	return _npstat.IntAbsNtuple_title(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.IntAbsNtuple_setTitle(self, newtitle)

	def nColumns(self) -> "unsigned long":
	return _npstat.IntAbsNtuple_nColumns(self)

	def columnName(self, i: 'unsigned long const') -> "std::string const &":
	return _npstat.IntAbsNtuple_columnName(self, i)

	def columnNames(self) -> "std::vector< std::string,std::allocator< std::string > > const &":
	return _npstat.IntAbsNtuple_columnNames(self)

	def setColumnName(self, i: 'unsigned long', newname: 'char const *') -> "bool":
	return _npstat.IntAbsNtuple_setColumnName(self, i, newname)

	def columnNumber(self, columnName: 'char const *') -> "unsigned long":
	return _npstat.IntAbsNtuple_columnNumber(self, columnName)

	def validColumn(self, columnName: 'char const *') -> "unsigned long":
	return _npstat.IntAbsNtuple_validColumn(self, columnName)

	def nRows(self) -> "unsigned long":
	return _npstat.IntAbsNtuple_nRows(self)

	def length(self) -> "unsigned long":
	return _npstat.IntAbsNtuple_length(self)

	def fill(self, *args) -> "void":
	return _npstat.IntAbsNtuple_fill(self, *args)

	def __call__(self, r: 'unsigned long', c: 'unsigned long') -> "int":
	return _npstat.IntAbsNtuple___call__(self, r, c)

	def at(self, r: 'unsigned long', c: 'unsigned long') -> "int":
	return _npstat.IntAbsNtuple_at(self, r, c)

	def element(self, r: 'unsigned long', c: 'Column') -> "int":
	return _npstat.IntAbsNtuple_element(self, r, c)

	def elementAt(self, r: 'unsigned long', c: 'Column') -> "int":
	return _npstat.IntAbsNtuple_elementAt(self, r, c)

	def rowContents(self, row: 'unsigned long', buf: 'int *', lenBuf: 'unsigned long') -> "void":
	return _npstat.IntAbsNtuple_rowContents(self, row, buf, lenBuf)

	def columnContents(self, c: 'Column', buf: 'int *', lenBuf: 'unsigned long') -> "void":
	return _npstat.IntAbsNtuple_columnContents(self, c, buf, lenBuf)

	def clear(self) -> "void":
	return _npstat.IntAbsNtuple_clear(self)

	def row_begin(self, rowNumber: 'unsigned long') -> "npstat::AbsNtuple< int >::row_iterator":
	return _npstat.IntAbsNtuple_row_begin(self, rowNumber)

	def row_end(self) -> "npstat::AbsNtuple< int >::row_iterator":
	return _npstat.IntAbsNtuple_row_end(self)

	def column_begin(self, column: 'Column') -> "npstat::AbsNtuple< int >::column_iterator":
	return _npstat.IntAbsNtuple_column_begin(self, column)

	def column_end(self) -> "npstat::AbsNtuple< int >::column_iterator":
	return _npstat.IntAbsNtuple_column_end(self)

	def columnIndices(self, *args) -> "std::vector< unsigned long,std::allocator< unsigned long > >":
	return _npstat.IntAbsNtuple_columnIndices(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.IntAbsNtuple_classId(self)

	def __eq__(self, r: 'IntAbsNtuple') -> "bool":
	return _npstat.IntAbsNtuple___eq__(self, r)

	def __ne__(self, r: 'IntAbsNtuple') -> "bool":
	return _npstat.IntAbsNtuple___ne__(self, r)

	def append(self, other: 'IntAbsNtuple') -> "void":
	return _npstat.IntAbsNtuple_append(self, other)

	def columnArray(self, args) -> "PyObject ":
	return _npstat.IntAbsNtuple_columnArray(self, *args)

	def rowArray(self, row: 'unsigned long') -> "PyObject *":
	return _npstat.IntAbsNtuple_rowArray(self, row)

	def cycleOverRows(self, *args) -> "void":
	return _npstat.IntAbsNtuple_cycleOverRows(self, *args)

	def cutCycleOverRows(self, *args) -> "unsigned long":
	return _npstat.IntAbsNtuple_cutCycleOverRows(self, *args)
	IntAbsNtuple_swigregister = _npstat.IntAbsNtuple_swigregister
	IntAbsNtuple_swigregister(IntAbsNtuple)

	class LLongAbsNtuple(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongAbsNtuple, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongAbsNtuple, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LLongAbsNtuple
	__del__ = lambda self: None

	def title(self) -> "std::string const &":
	return _npstat.LLongAbsNtuple_title(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.LLongAbsNtuple_setTitle(self, newtitle)

	def nColumns(self) -> "unsigned long":
	return _npstat.LLongAbsNtuple_nColumns(self)

	def columnName(self, i: 'unsigned long const') -> "std::string const &":
	return _npstat.LLongAbsNtuple_columnName(self, i)

	def columnNames(self) -> "std::vector< std::string,std::allocator< std::string > > const &":
	return _npstat.LLongAbsNtuple_columnNames(self)

	def setColumnName(self, i: 'unsigned long', newname: 'char const *') -> "bool":
	return _npstat.LLongAbsNtuple_setColumnName(self, i, newname)

	def columnNumber(self, columnName: 'char const *') -> "unsigned long":
	return _npstat.LLongAbsNtuple_columnNumber(self, columnName)

	def validColumn(self, columnName: 'char const *') -> "unsigned long":
	return _npstat.LLongAbsNtuple_validColumn(self, columnName)

	def nRows(self) -> "unsigned long":
	return _npstat.LLongAbsNtuple_nRows(self)

	def length(self) -> "unsigned long":
	return _npstat.LLongAbsNtuple_length(self)

	def fill(self, *args) -> "void":
	return _npstat.LLongAbsNtuple_fill(self, *args)

	def __call__(self, r: 'unsigned long', c: 'unsigned long') -> "long long":
	return _npstat.LLongAbsNtuple___call__(self, r, c)

	def at(self, r: 'unsigned long', c: 'unsigned long') -> "long long":
	return _npstat.LLongAbsNtuple_at(self, r, c)

	def element(self, r: 'unsigned long', c: 'Column') -> "long long":
	return _npstat.LLongAbsNtuple_element(self, r, c)

	def elementAt(self, r: 'unsigned long', c: 'Column') -> "long long":
	return _npstat.LLongAbsNtuple_elementAt(self, r, c)

	def rowContents(self, row: 'unsigned long', buf: 'long long *', lenBuf: 'unsigned long') -> "void":
	return _npstat.LLongAbsNtuple_rowContents(self, row, buf, lenBuf)

	def columnContents(self, c: 'Column', buf: 'long long *', lenBuf: 'unsigned long') -> "void":
	return _npstat.LLongAbsNtuple_columnContents(self, c, buf, lenBuf)

	def clear(self) -> "void":
	return _npstat.LLongAbsNtuple_clear(self)

	def row_begin(self, rowNumber: 'unsigned long') -> "npstat::AbsNtuple< long long >::row_iterator":
	return _npstat.LLongAbsNtuple_row_begin(self, rowNumber)

	def row_end(self) -> "npstat::AbsNtuple< long long >::row_iterator":
	return _npstat.LLongAbsNtuple_row_end(self)

	def column_begin(self, column: 'Column') -> "npstat::AbsNtuple< long long >::column_iterator":
	return _npstat.LLongAbsNtuple_column_begin(self, column)

	def column_end(self) -> "npstat::AbsNtuple< long long >::column_iterator":
	return _npstat.LLongAbsNtuple_column_end(self)

	def columnIndices(self, *args) -> "std::vector< unsigned long,std::allocator< unsigned long > >":
	return _npstat.LLongAbsNtuple_columnIndices(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.LLongAbsNtuple_classId(self)

	def __eq__(self, r: 'LLongAbsNtuple') -> "bool":
	return _npstat.LLongAbsNtuple___eq__(self, r)

	def __ne__(self, r: 'LLongAbsNtuple') -> "bool":
	return _npstat.LLongAbsNtuple___ne__(self, r)

	def append(self, other: 'LLongAbsNtuple') -> "void":
	return _npstat.LLongAbsNtuple_append(self, other)

	def columnArray(self, args) -> "PyObject ":
	return _npstat.LLongAbsNtuple_columnArray(self, *args)

	def rowArray(self, row: 'unsigned long') -> "PyObject *":
	return _npstat.LLongAbsNtuple_rowArray(self, row)

	def cycleOverRows(self, *args) -> "void":
	return _npstat.LLongAbsNtuple_cycleOverRows(self, *args)

	def cutCycleOverRows(self, *args) -> "unsigned long":
	return _npstat.LLongAbsNtuple_cutCycleOverRows(self, *args)
	LLongAbsNtuple_swigregister = _npstat.LLongAbsNtuple_swigregister
	LLongAbsNtuple_swigregister(LLongAbsNtuple)

	class FloatAbsNtuple(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatAbsNtuple, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatAbsNtuple, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatAbsNtuple
	__del__ = lambda self: None

	def title(self) -> "std::string const &":
	return _npstat.FloatAbsNtuple_title(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.FloatAbsNtuple_setTitle(self, newtitle)

	def nColumns(self) -> "unsigned long":
	return _npstat.FloatAbsNtuple_nColumns(self)

	def columnName(self, i: 'unsigned long const') -> "std::string const &":
	return _npstat.FloatAbsNtuple_columnName(self, i)

	def columnNames(self) -> "std::vector< std::string,std::allocator< std::string > > const &":
	return _npstat.FloatAbsNtuple_columnNames(self)

	def setColumnName(self, i: 'unsigned long', newname: 'char const *') -> "bool":
	return _npstat.FloatAbsNtuple_setColumnName(self, i, newname)

	def columnNumber(self, columnName: 'char const *') -> "unsigned long":
	return _npstat.FloatAbsNtuple_columnNumber(self, columnName)

	def validColumn(self, columnName: 'char const *') -> "unsigned long":
	return _npstat.FloatAbsNtuple_validColumn(self, columnName)

	def nRows(self) -> "unsigned long":
	return _npstat.FloatAbsNtuple_nRows(self)

	def length(self) -> "unsigned long":
	return _npstat.FloatAbsNtuple_length(self)

	def fill(self, *args) -> "void":
	return _npstat.FloatAbsNtuple_fill(self, *args)

	def __call__(self, r: 'unsigned long', c: 'unsigned long') -> "float":
	return _npstat.FloatAbsNtuple___call__(self, r, c)

	def at(self, r: 'unsigned long', c: 'unsigned long') -> "float":
	return _npstat.FloatAbsNtuple_at(self, r, c)

	def element(self, r: 'unsigned long', c: 'Column') -> "float":
	return _npstat.FloatAbsNtuple_element(self, r, c)

	def elementAt(self, r: 'unsigned long', c: 'Column') -> "float":
	return _npstat.FloatAbsNtuple_elementAt(self, r, c)

	def rowContents(self, row: 'unsigned long', buf: 'float *', lenBuf: 'unsigned long') -> "void":
	return _npstat.FloatAbsNtuple_rowContents(self, row, buf, lenBuf)

	def columnContents(self, c: 'Column', buf: 'float *', lenBuf: 'unsigned long') -> "void":
	return _npstat.FloatAbsNtuple_columnContents(self, c, buf, lenBuf)

	def clear(self) -> "void":
	return _npstat.FloatAbsNtuple_clear(self)

	def row_begin(self, rowNumber: 'unsigned long') -> "npstat::AbsNtuple< float >::row_iterator":
	return _npstat.FloatAbsNtuple_row_begin(self, rowNumber)

	def row_end(self) -> "npstat::AbsNtuple< float >::row_iterator":
	return _npstat.FloatAbsNtuple_row_end(self)

	def column_begin(self, column: 'Column') -> "npstat::AbsNtuple< float >::column_iterator":
	return _npstat.FloatAbsNtuple_column_begin(self, column)

	def column_end(self) -> "npstat::AbsNtuple< float >::column_iterator":
	return _npstat.FloatAbsNtuple_column_end(self)

	def columnIndices(self, *args) -> "std::vector< unsigned long,std::allocator< unsigned long > >":
	return _npstat.FloatAbsNtuple_columnIndices(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatAbsNtuple_classId(self)

	def __eq__(self, r: 'FloatAbsNtuple') -> "bool":
	return _npstat.FloatAbsNtuple___eq__(self, r)

	def __ne__(self, r: 'FloatAbsNtuple') -> "bool":
	return _npstat.FloatAbsNtuple___ne__(self, r)

	def append(self, other: 'FloatAbsNtuple') -> "void":
	return _npstat.FloatAbsNtuple_append(self, other)

	def columnArray(self, args) -> "PyObject ":
	return _npstat.FloatAbsNtuple_columnArray(self, *args)

	def rowArray(self, row: 'unsigned long') -> "PyObject *":
	return _npstat.FloatAbsNtuple_rowArray(self, row)

	def cycleOverRows(self, *args) -> "void":
	return _npstat.FloatAbsNtuple_cycleOverRows(self, *args)

	def cutCycleOverRows(self, *args) -> "unsigned long":
	return _npstat.FloatAbsNtuple_cutCycleOverRows(self, *args)
	FloatAbsNtuple_swigregister = _npstat.FloatAbsNtuple_swigregister
	FloatAbsNtuple_swigregister(FloatAbsNtuple)

	class DoubleAbsNtuple(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleAbsNtuple, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleAbsNtuple, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleAbsNtuple
	__del__ = lambda self: None

	def title(self) -> "std::string const &":
	return _npstat.DoubleAbsNtuple_title(self)

	def setTitle(self, newtitle: 'char const *') -> "void":
	return _npstat.DoubleAbsNtuple_setTitle(self, newtitle)

	def nColumns(self) -> "unsigned long":
	return _npstat.DoubleAbsNtuple_nColumns(self)

	def columnName(self, i: 'unsigned long const') -> "std::string const &":
	return _npstat.DoubleAbsNtuple_columnName(self, i)

	def columnNames(self) -> "std::vector< std::string,std::allocator< std::string > > const &":
	return _npstat.DoubleAbsNtuple_columnNames(self)

	def setColumnName(self, i: 'unsigned long', newname: 'char const *') -> "bool":
	return _npstat.DoubleAbsNtuple_setColumnName(self, i, newname)

	def columnNumber(self, columnName: 'char const *') -> "unsigned long":
	return _npstat.DoubleAbsNtuple_columnNumber(self, columnName)

	def validColumn(self, columnName: 'char const *') -> "unsigned long":
	return _npstat.DoubleAbsNtuple_validColumn(self, columnName)

	def nRows(self) -> "unsigned long":
	return _npstat.DoubleAbsNtuple_nRows(self)

	def length(self) -> "unsigned long":
	return _npstat.DoubleAbsNtuple_length(self)

	def fill(self, *args) -> "void":
	return _npstat.DoubleAbsNtuple_fill(self, *args)

	def __call__(self, r: 'unsigned long', c: 'unsigned long') -> "double":
	return _npstat.DoubleAbsNtuple___call__(self, r, c)

	def at(self, r: 'unsigned long', c: 'unsigned long') -> "double":
	return _npstat.DoubleAbsNtuple_at(self, r, c)

	def element(self, r: 'unsigned long', c: 'Column') -> "double":
	return _npstat.DoubleAbsNtuple_element(self, r, c)

	def elementAt(self, r: 'unsigned long', c: 'Column') -> "double":
	return _npstat.DoubleAbsNtuple_elementAt(self, r, c)

	def rowContents(self, row: 'unsigned long', buf: 'double *', lenBuf: 'unsigned long') -> "void":
	return _npstat.DoubleAbsNtuple_rowContents(self, row, buf, lenBuf)

	def columnContents(self, c: 'Column', buf: 'double *', lenBuf: 'unsigned long') -> "void":
	return _npstat.DoubleAbsNtuple_columnContents(self, c, buf, lenBuf)

	def clear(self) -> "void":
	return _npstat.DoubleAbsNtuple_clear(self)

	def row_begin(self, rowNumber: 'unsigned long') -> "npstat::AbsNtuple< double >::row_iterator":
	return _npstat.DoubleAbsNtuple_row_begin(self, rowNumber)

	def row_end(self) -> "npstat::AbsNtuple< double >::row_iterator":
	return _npstat.DoubleAbsNtuple_row_end(self)

	def column_begin(self, column: 'Column') -> "npstat::AbsNtuple< double >::column_iterator":
	return _npstat.DoubleAbsNtuple_column_begin(self, column)

	def column_end(self) -> "npstat::AbsNtuple< double >::column_iterator":
	return _npstat.DoubleAbsNtuple_column_end(self)

	def columnIndices(self, *args) -> "std::vector< unsigned long,std::allocator< unsigned long > >":
	return _npstat.DoubleAbsNtuple_columnIndices(self, *args)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleAbsNtuple_classId(self)

	def __eq__(self, r: 'DoubleAbsNtuple') -> "bool":
	return _npstat.DoubleAbsNtuple___eq__(self, r)

	def __ne__(self, r: 'DoubleAbsNtuple') -> "bool":
	return _npstat.DoubleAbsNtuple___ne__(self, r)

	def append(self, other: 'DoubleAbsNtuple') -> "void":
	return _npstat.DoubleAbsNtuple_append(self, other)

	def columnArray(self, args) -> "PyObject ":
	return _npstat.DoubleAbsNtuple_columnArray(self, *args)

	def rowArray(self, row: 'unsigned long') -> "PyObject *":
	return _npstat.DoubleAbsNtuple_rowArray(self, row)

	def cycleOverRows(self, *args) -> "void":
	return _npstat.DoubleAbsNtuple_cycleOverRows(self, *args)

	def cutCycleOverRows(self, *args) -> "unsigned long":
	return _npstat.DoubleAbsNtuple_cutCycleOverRows(self, *args)
	DoubleAbsNtuple_swigregister = _npstat.DoubleAbsNtuple_swigregister
	DoubleAbsNtuple_swigregister(DoubleAbsNtuple)


	def dumpNtupleAsText(*args) -> "bool":
	return _npstat.dumpNtupleAsText(*args)
	dumpNtupleAsText = _npstat.dumpNtupleAsText

	def fillNtupleFromText(*args) -> "bool":
	return _npstat.fillNtupleFromText(*args)
	fillNtupleFromText = _npstat.fillNtupleFromText
	class ItemLocation(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, ItemLocation, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, ItemLocation, name)
	__repr__ = _swig_repr

	def __init__(self, pos: 'std::streampos', URI: 'char const ', cachedItemURI: 'char const '=None):
	this = _npstat.new_ItemLocation(pos, URI, cachedItemURI)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def URI(self) -> "std::string const &":
	return _npstat.ItemLocation_URI(self)

	def cachedItemURI(self) -> "std::string const &":
	return _npstat.ItemLocation_cachedItemURI(self)

	def setURI(self, newURI: 'char const *') -> "void":
	return _npstat.ItemLocation_setURI(self, newURI)

	def setCachedItemURI(self, newURI: 'char const *') -> "void":
	return _npstat.ItemLocation_setCachedItemURI(self, newURI)

	def __eq__(self, r: 'ItemLocation') -> "bool":
	return _npstat.ItemLocation___eq__(self, r)

	def __ne__(self, r: 'ItemLocation') -> "bool":
	return _npstat.ItemLocation___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.ItemLocation_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.ItemLocation_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.ItemLocation_classname)
	else:
	classname = _npstat.ItemLocation_classname
	if _newclass:
	version = staticmethod(_npstat.ItemLocation_version)
	else:
	version = _npstat.ItemLocation_version
	if _newclass:
	read = staticmethod(_npstat.ItemLocation_read)
	else:
	read = _npstat.ItemLocation_read

	def streamPos(self) -> "long long":
	return _npstat.ItemLocation_streamPos(self)

	def setStreamPos(self, pos: 'long long const') -> "void":
	return _npstat.ItemLocation_setStreamPos(self, pos)
	__swig_destroy__ = _npstat.delete_ItemLocation
	__del__ = lambda self: None
	ItemLocation_swigregister = _npstat.ItemLocation_swigregister
	ItemLocation_swigregister(ItemLocation)

	def ItemLocation_classname() -> "char const *":
	return _npstat.ItemLocation_classname()
	ItemLocation_classname = _npstat.ItemLocation_classname

	def ItemLocation_version() -> "unsigned int":
	return _npstat.ItemLocation_version()
	ItemLocation_version = _npstat.ItemLocation_version

	def ItemLocation_read(id: 'ClassId', arg3: 'istream') -> "gs::ItemLocation *":
	return _npstat.ItemLocation_read(id, arg3)
	ItemLocation_read = _npstat.ItemLocation_read

	class CatalogEntry(ItemDescriptor):
	__swig_setmethods__ = {}
	for _s in [ItemDescriptor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, CatalogEntry, name, value)
	__swig_getmethods__ = {}
	for _s in [ItemDescriptor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, CatalogEntry, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_CatalogEntry(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_CatalogEntry
	__del__ = lambda self: None

	def id(self) -> "unsigned long long":
	return _npstat.CatalogEntry_id(self)

	def offset(self) -> "unsigned long long":
	return _npstat.CatalogEntry_offset(self)

	def location(self) -> "gs::ItemLocation const &":
	return _npstat.CatalogEntry_location(self)

	def itemLength(self) -> "unsigned long long":
	return _npstat.CatalogEntry_itemLength(self)

	def compressionCode(self) -> "unsigned int":
	return _npstat.CatalogEntry_compressionCode(self)

	def setStreamPosition(self, pos: 'std::streampos') -> "gs::CatalogEntry &":
	return _npstat.CatalogEntry_setStreamPosition(self, pos)

	def setURI(self, newURI: 'char const *') -> "gs::CatalogEntry &":
	return _npstat.CatalogEntry_setURI(self, newURI)

	def setCachedItemURI(self, newURI: 'char const *') -> "gs::CatalogEntry &":
	return _npstat.CatalogEntry_setCachedItemURI(self, newURI)

	def setOffset(self, off: 'unsigned long long const') -> "gs::CatalogEntry &":
	return _npstat.CatalogEntry_setOffset(self, off)

	def humanReadable(self, os: 'ostream') -> "bool":
	return _npstat.CatalogEntry_humanReadable(self, os)

	def classId(self) -> "gs::ClassId":
	return _npstat.CatalogEntry_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.CatalogEntry_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.CatalogEntry_classname)
	else:
	classname = _npstat.CatalogEntry_classname
	if _newclass:
	version = staticmethod(_npstat.CatalogEntry_version)
	else:
	version = _npstat.CatalogEntry_version
	if _newclass:
	read = staticmethod(_npstat.CatalogEntry_read)
	else:
	read = _npstat.CatalogEntry_read
	CatalogEntry_swigregister = _npstat.CatalogEntry_swigregister
	CatalogEntry_swigregister(CatalogEntry)

	def CatalogEntry_classname() -> "char const *":
	return _npstat.CatalogEntry_classname()
	CatalogEntry_classname = _npstat.CatalogEntry_classname

	def CatalogEntry_version() -> "unsigned int":
	return _npstat.CatalogEntry_version()
	CatalogEntry_version = _npstat.CatalogEntry_version

	def CatalogEntry_read(id: 'ClassId', locId: 'ClassId', arg4: 'istream') -> "gs::CatalogEntry *":
	return _npstat.CatalogEntry_read(id, locId, arg4)
	CatalogEntry_read = _npstat.CatalogEntry_read

	class AbsArchive(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsArchive, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, AbsArchive, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsArchive
	__del__ = lambda self: None

	def name(self) -> "std::string const &":
	return _npstat.AbsArchive_name(self)

	def isOpen(self) -> "bool":
	return _npstat.AbsArchive_isOpen(self)

	def error(self) -> "std::string":
	return _npstat.AbsArchive_error(self)

	def isReadable(self) -> "bool":
	return _npstat.AbsArchive_isReadable(self)

	def isWritable(self) -> "bool":
	return _npstat.AbsArchive_isWritable(self)

	def size(self) -> "unsigned long long":
	return _npstat.AbsArchive_size(self)

	def smallestId(self) -> "unsigned long long":
	return _npstat.AbsArchive_smallestId(self)

	def largestId(self) -> "unsigned long long":
	return _npstat.AbsArchive_largestId(self)

	def idsAreContiguous(self) -> "bool":
	return _npstat.AbsArchive_idsAreContiguous(self)

	def itemExists(self, id: 'unsigned long long') -> "bool":
	return _npstat.AbsArchive_itemExists(self, id)

	def itemSearch(self, namePattern: 'SearchSpecifier', categoryPattern: 'SearchSpecifier', found: 'ULLongVector') -> "void":
	return _npstat.AbsArchive_itemSearch(self, namePattern, categoryPattern, found)

	def flush(self) -> "void":
	return _npstat.AbsArchive_flush(self)

	def copyItem(self, id: 'unsigned long long', destination: 'AbsArchive', newName: 'char const '=None, newCategory: 'char const '=None) -> "unsigned long long":
	return _npstat.AbsArchive_copyItem(self, id, destination, newName, newCategory)

	def lastItemId(self) -> "unsigned long long":
	return _npstat.AbsArchive_lastItemId(self)

	def lastItemLength(self) -> "unsigned long long":
	return _npstat.AbsArchive_lastItemLength(self)

	def __eq__(self, r: 'AbsArchive') -> "bool":
	return _npstat.AbsArchive___eq__(self, r)

	def __ne__(self, r: 'AbsArchive') -> "bool":
	return _npstat.AbsArchive___ne__(self, r)

	def categories(self) -> "PyObject *":
	return _npstat.AbsArchive_categories(self)

	def store(self, record: 'AbsRecord') -> "gs::AbsArchive &":
	return _npstat.AbsArchive_store(self, record)

	def findItems(self, *args) -> "std::vector< unsigned long long,std::allocator< unsigned long long > >":
	return _npstat.AbsArchive_findItems(self, *args)

	def getCatalogEntry(self, iid: 'unsigned long long') -> "gs::CatalogEntry":
	return _npstat.AbsArchive_getCatalogEntry(self, iid)
	AbsArchive_swigregister = _npstat.AbsArchive_swigregister
	AbsArchive_swigregister(AbsArchive)

	class UCharArchivedNtuple(UCharAbsNtuple):
	__swig_setmethods__ = {}
	for _s in [UCharAbsNtuple]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharArchivedNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [UCharAbsNtuple]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UCharArchivedNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, columnNames: 'StringVector', title: 'char const ', archive: 'AbsArchive', name: 'char const ', category: 'char const *', rowsPerBuffer: 'unsigned long', writeColumnWise: 'bool'=False):
	this = _npstat.new_UCharArchivedNtuple(columnNames, title, archive, name, category, rowsPerBuffer, writeColumnWise)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UCharArchivedNtuple
	def __del__(self):

	myClassIdTmp = self.classId().name()
	myNumberTmp = self.objectNumber()
	statusTmp = True
	if self.isWritable():
	statusTmp = self.write()



	import npstat_utils
	npstat_utils._unregisterArchivedNtuple(myClassIdTmp, myNumberTmp)
	if not statusTmp:
	raise IOError("failed to write %s object to the archive" % myClassIdTmp)


	pass


	def archive(self) -> "gs::AbsArchive &":
	return _npstat.UCharArchivedNtuple_archive(self)

	def name(self) -> "std::string const &":
	return _npstat.UCharArchivedNtuple_name(self)

	def category(self) -> "std::string const &":
	return _npstat.UCharArchivedNtuple_category(self)

	def rowsPerBuffer(self) -> "unsigned long":
	return _npstat.UCharArchivedNtuple_rowsPerBuffer(self)

	def writesByColumn(self) -> "bool":
	return _npstat.UCharArchivedNtuple_writesByColumn(self)

	def isReadable(self) -> "bool":
	return _npstat.UCharArchivedNtuple_isReadable(self)

	def isWritable(self) -> "bool":
	return _npstat.UCharArchivedNtuple_isWritable(self)

	def objectNumber(self) -> "unsigned long":
	return _npstat.UCharArchivedNtuple_objectNumber(self)

	def fill(self, *args) -> "void":
	return _npstat.UCharArchivedNtuple_fill(self, *args)

	def nRows(self) -> "unsigned long":
	return _npstat.UCharArchivedNtuple_nRows(self)

	def __call__(self, row: 'unsigned long const', column: 'unsigned long const') -> "unsigned char":
	return _npstat.UCharArchivedNtuple___call__(self, row, column)

	def at(self, row: 'unsigned long const', column: 'unsigned long const') -> "unsigned char":
	return _npstat.UCharArchivedNtuple_at(self, row, column)

	def rowContents(self, row: 'unsigned long const', buffer: 'unsigned char *', lenBuffer: 'unsigned long') -> "void":
	return _npstat.UCharArchivedNtuple_rowContents(self, row, buffer, lenBuffer)

	def columnContents(self, c: 'Column', buffer: 'unsigned char *', lenBuffer: 'unsigned long') -> "void":
	return _npstat.UCharArchivedNtuple_columnContents(self, c, buffer, lenBuffer)

	def clear(self) -> "void":
	return _npstat.UCharArchivedNtuple_clear(self)

	def write(self) -> "bool":
	return _npstat.UCharArchivedNtuple_write(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.UCharArchivedNtuple_classId(self)
	if _newclass:
	classname = staticmethod(_npstat.UCharArchivedNtuple_classname)
	else:
	classname = _npstat.UCharArchivedNtuple_classname
	if _newclass:
	version = staticmethod(_npstat.UCharArchivedNtuple_version)
	else:
	version = _npstat.UCharArchivedNtuple_version
	UCharArchivedNtuple_swigregister = _npstat.UCharArchivedNtuple_swigregister
	UCharArchivedNtuple_swigregister(UCharArchivedNtuple)

	def UCharArchivedNtuple_classname() -> "char const *":
	return _npstat.UCharArchivedNtuple_classname()
	UCharArchivedNtuple_classname = _npstat.UCharArchivedNtuple_classname

	def UCharArchivedNtuple_version() -> "unsigned int":
	return _npstat.UCharArchivedNtuple_version()
	UCharArchivedNtuple_version = _npstat.UCharArchivedNtuple_version

	class IntArchivedNtuple(IntAbsNtuple):
	__swig_setmethods__ = {}
	for _s in [IntAbsNtuple]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntArchivedNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [IntAbsNtuple]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, IntArchivedNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, columnNames: 'StringVector', title: 'char const ', archive: 'AbsArchive', name: 'char const ', category: 'char const *', rowsPerBuffer: 'unsigned long', writeColumnWise: 'bool'=False):
	this = _npstat.new_IntArchivedNtuple(columnNames, title, archive, name, category, rowsPerBuffer, writeColumnWise)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_IntArchivedNtuple
	def __del__(self):

	myClassIdTmp = self.classId().name()
	myNumberTmp = self.objectNumber()
	statusTmp = True
	if self.isWritable():
	statusTmp = self.write()



	import npstat_utils
	npstat_utils._unregisterArchivedNtuple(myClassIdTmp, myNumberTmp)
	if not statusTmp:
	raise IOError("failed to write %s object to the archive" % myClassIdTmp)


	pass


	def archive(self) -> "gs::AbsArchive &":
	return _npstat.IntArchivedNtuple_archive(self)

	def name(self) -> "std::string const &":
	return _npstat.IntArchivedNtuple_name(self)

	def category(self) -> "std::string const &":
	return _npstat.IntArchivedNtuple_category(self)

	def rowsPerBuffer(self) -> "unsigned long":
	return _npstat.IntArchivedNtuple_rowsPerBuffer(self)

	def writesByColumn(self) -> "bool":
	return _npstat.IntArchivedNtuple_writesByColumn(self)

	def isReadable(self) -> "bool":
	return _npstat.IntArchivedNtuple_isReadable(self)

	def isWritable(self) -> "bool":
	return _npstat.IntArchivedNtuple_isWritable(self)

	def objectNumber(self) -> "unsigned long":
	return _npstat.IntArchivedNtuple_objectNumber(self)

	def fill(self, *args) -> "void":
	return _npstat.IntArchivedNtuple_fill(self, *args)

	def nRows(self) -> "unsigned long":
	return _npstat.IntArchivedNtuple_nRows(self)

	def __call__(self, row: 'unsigned long const', column: 'unsigned long const') -> "int":
	return _npstat.IntArchivedNtuple___call__(self, row, column)

	def at(self, row: 'unsigned long const', column: 'unsigned long const') -> "int":
	return _npstat.IntArchivedNtuple_at(self, row, column)

	def rowContents(self, row: 'unsigned long const', buffer: 'int *', lenBuffer: 'unsigned long') -> "void":
	return _npstat.IntArchivedNtuple_rowContents(self, row, buffer, lenBuffer)

	def columnContents(self, c: 'Column', buffer: 'int *', lenBuffer: 'unsigned long') -> "void":
	return _npstat.IntArchivedNtuple_columnContents(self, c, buffer, lenBuffer)

	def clear(self) -> "void":
	return _npstat.IntArchivedNtuple_clear(self)

	def write(self) -> "bool":
	return _npstat.IntArchivedNtuple_write(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.IntArchivedNtuple_classId(self)
	if _newclass:
	classname = staticmethod(_npstat.IntArchivedNtuple_classname)
	else:
	classname = _npstat.IntArchivedNtuple_classname
	if _newclass:
	version = staticmethod(_npstat.IntArchivedNtuple_version)
	else:
	version = _npstat.IntArchivedNtuple_version
	IntArchivedNtuple_swigregister = _npstat.IntArchivedNtuple_swigregister
	IntArchivedNtuple_swigregister(IntArchivedNtuple)

	def IntArchivedNtuple_classname() -> "char const *":
	return _npstat.IntArchivedNtuple_classname()
	IntArchivedNtuple_classname = _npstat.IntArchivedNtuple_classname

	def IntArchivedNtuple_version() -> "unsigned int":
	return _npstat.IntArchivedNtuple_version()
	IntArchivedNtuple_version = _npstat.IntArchivedNtuple_version

	class LLongArchivedNtuple(LLongAbsNtuple):
	__swig_setmethods__ = {}
	for _s in [LLongAbsNtuple]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongArchivedNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [LLongAbsNtuple]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LLongArchivedNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, columnNames: 'StringVector', title: 'char const ', archive: 'AbsArchive', name: 'char const ', category: 'char const *', rowsPerBuffer: 'unsigned long', writeColumnWise: 'bool'=False):
	this = _npstat.new_LLongArchivedNtuple(columnNames, title, archive, name, category, rowsPerBuffer, writeColumnWise)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_LLongArchivedNtuple
	def __del__(self):

	myClassIdTmp = self.classId().name()
	myNumberTmp = self.objectNumber()
	statusTmp = True
	if self.isWritable():
	statusTmp = self.write()



	import npstat_utils
	npstat_utils._unregisterArchivedNtuple(myClassIdTmp, myNumberTmp)
	if not statusTmp:
	raise IOError("failed to write %s object to the archive" % myClassIdTmp)


	pass


	def archive(self) -> "gs::AbsArchive &":
	return _npstat.LLongArchivedNtuple_archive(self)

	def name(self) -> "std::string const &":
	return _npstat.LLongArchivedNtuple_name(self)

	def category(self) -> "std::string const &":
	return _npstat.LLongArchivedNtuple_category(self)

	def rowsPerBuffer(self) -> "unsigned long":
	return _npstat.LLongArchivedNtuple_rowsPerBuffer(self)

	def writesByColumn(self) -> "bool":
	return _npstat.LLongArchivedNtuple_writesByColumn(self)

	def isReadable(self) -> "bool":
	return _npstat.LLongArchivedNtuple_isReadable(self)

	def isWritable(self) -> "bool":
	return _npstat.LLongArchivedNtuple_isWritable(self)

	def objectNumber(self) -> "unsigned long":
	return _npstat.LLongArchivedNtuple_objectNumber(self)

	def fill(self, *args) -> "void":
	return _npstat.LLongArchivedNtuple_fill(self, *args)

	def nRows(self) -> "unsigned long":
	return _npstat.LLongArchivedNtuple_nRows(self)

	def __call__(self, row: 'unsigned long const', column: 'unsigned long const') -> "long long":
	return _npstat.LLongArchivedNtuple___call__(self, row, column)

	def at(self, row: 'unsigned long const', column: 'unsigned long const') -> "long long":
	return _npstat.LLongArchivedNtuple_at(self, row, column)

	def rowContents(self, row: 'unsigned long const', buffer: 'long long *', lenBuffer: 'unsigned long') -> "void":
	return _npstat.LLongArchivedNtuple_rowContents(self, row, buffer, lenBuffer)

	def columnContents(self, c: 'Column', buffer: 'long long *', lenBuffer: 'unsigned long') -> "void":
	return _npstat.LLongArchivedNtuple_columnContents(self, c, buffer, lenBuffer)

	def clear(self) -> "void":
	return _npstat.LLongArchivedNtuple_clear(self)

	def write(self) -> "bool":
	return _npstat.LLongArchivedNtuple_write(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.LLongArchivedNtuple_classId(self)
	if _newclass:
	classname = staticmethod(_npstat.LLongArchivedNtuple_classname)
	else:
	classname = _npstat.LLongArchivedNtuple_classname
	if _newclass:
	version = staticmethod(_npstat.LLongArchivedNtuple_version)
	else:
	version = _npstat.LLongArchivedNtuple_version
	LLongArchivedNtuple_swigregister = _npstat.LLongArchivedNtuple_swigregister
	LLongArchivedNtuple_swigregister(LLongArchivedNtuple)

	def LLongArchivedNtuple_classname() -> "char const *":
	return _npstat.LLongArchivedNtuple_classname()
	LLongArchivedNtuple_classname = _npstat.LLongArchivedNtuple_classname

	def LLongArchivedNtuple_version() -> "unsigned int":
	return _npstat.LLongArchivedNtuple_version()
	LLongArchivedNtuple_version = _npstat.LLongArchivedNtuple_version

	class FloatArchivedNtuple(FloatAbsNtuple):
	__swig_setmethods__ = {}
	for _s in [FloatAbsNtuple]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatArchivedNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [FloatAbsNtuple]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatArchivedNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, columnNames: 'StringVector', title: 'char const ', archive: 'AbsArchive', name: 'char const ', category: 'char const *', rowsPerBuffer: 'unsigned long', writeColumnWise: 'bool'=False):
	this = _npstat.new_FloatArchivedNtuple(columnNames, title, archive, name, category, rowsPerBuffer, writeColumnWise)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatArchivedNtuple
	def __del__(self):

	myClassIdTmp = self.classId().name()
	myNumberTmp = self.objectNumber()
	statusTmp = True
	if self.isWritable():
	statusTmp = self.write()



	import npstat_utils
	npstat_utils._unregisterArchivedNtuple(myClassIdTmp, myNumberTmp)
	if not statusTmp:
	raise IOError("failed to write %s object to the archive" % myClassIdTmp)


	pass


	def archive(self) -> "gs::AbsArchive &":
	return _npstat.FloatArchivedNtuple_archive(self)

	def name(self) -> "std::string const &":
	return _npstat.FloatArchivedNtuple_name(self)

	def category(self) -> "std::string const &":
	return _npstat.FloatArchivedNtuple_category(self)

	def rowsPerBuffer(self) -> "unsigned long":
	return _npstat.FloatArchivedNtuple_rowsPerBuffer(self)

	def writesByColumn(self) -> "bool":
	return _npstat.FloatArchivedNtuple_writesByColumn(self)

	def isReadable(self) -> "bool":
	return _npstat.FloatArchivedNtuple_isReadable(self)

	def isWritable(self) -> "bool":
	return _npstat.FloatArchivedNtuple_isWritable(self)

	def objectNumber(self) -> "unsigned long":
	return _npstat.FloatArchivedNtuple_objectNumber(self)

	def fill(self, *args) -> "void":
	return _npstat.FloatArchivedNtuple_fill(self, *args)

	def nRows(self) -> "unsigned long":
	return _npstat.FloatArchivedNtuple_nRows(self)

	def __call__(self, row: 'unsigned long const', column: 'unsigned long const') -> "float":
	return _npstat.FloatArchivedNtuple___call__(self, row, column)

	def at(self, row: 'unsigned long const', column: 'unsigned long const') -> "float":
	return _npstat.FloatArchivedNtuple_at(self, row, column)

	def rowContents(self, row: 'unsigned long const', buffer: 'float *', lenBuffer: 'unsigned long') -> "void":
	return _npstat.FloatArchivedNtuple_rowContents(self, row, buffer, lenBuffer)

	def columnContents(self, c: 'Column', buffer: 'float *', lenBuffer: 'unsigned long') -> "void":
	return _npstat.FloatArchivedNtuple_columnContents(self, c, buffer, lenBuffer)

	def clear(self) -> "void":
	return _npstat.FloatArchivedNtuple_clear(self)

	def write(self) -> "bool":
	return _npstat.FloatArchivedNtuple_write(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatArchivedNtuple_classId(self)
	if _newclass:
	classname = staticmethod(_npstat.FloatArchivedNtuple_classname)
	else:
	classname = _npstat.FloatArchivedNtuple_classname
	if _newclass:
	version = staticmethod(_npstat.FloatArchivedNtuple_version)
	else:
	version = _npstat.FloatArchivedNtuple_version
	FloatArchivedNtuple_swigregister = _npstat.FloatArchivedNtuple_swigregister
	FloatArchivedNtuple_swigregister(FloatArchivedNtuple)

	def FloatArchivedNtuple_classname() -> "char const *":
	return _npstat.FloatArchivedNtuple_classname()
	FloatArchivedNtuple_classname = _npstat.FloatArchivedNtuple_classname

	def FloatArchivedNtuple_version() -> "unsigned int":
	return _npstat.FloatArchivedNtuple_version()
	FloatArchivedNtuple_version = _npstat.FloatArchivedNtuple_version

	class DoubleArchivedNtuple(DoubleAbsNtuple):
	__swig_setmethods__ = {}
	for _s in [DoubleAbsNtuple]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleArchivedNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleAbsNtuple]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleArchivedNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, columnNames: 'StringVector', title: 'char const ', archive: 'AbsArchive', name: 'char const ', category: 'char const *', rowsPerBuffer: 'unsigned long', writeColumnWise: 'bool'=False):
	this = _npstat.new_DoubleArchivedNtuple(columnNames, title, archive, name, category, rowsPerBuffer, writeColumnWise)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleArchivedNtuple
	def __del__(self):

	myClassIdTmp = self.classId().name()
	myNumberTmp = self.objectNumber()
	statusTmp = True
	if self.isWritable():
	statusTmp = self.write()



	import npstat_utils
	npstat_utils._unregisterArchivedNtuple(myClassIdTmp, myNumberTmp)
	if not statusTmp:
	raise IOError("failed to write %s object to the archive" % myClassIdTmp)


	pass


	def archive(self) -> "gs::AbsArchive &":
	return _npstat.DoubleArchivedNtuple_archive(self)

	def name(self) -> "std::string const &":
	return _npstat.DoubleArchivedNtuple_name(self)

	def category(self) -> "std::string const &":
	return _npstat.DoubleArchivedNtuple_category(self)

	def rowsPerBuffer(self) -> "unsigned long":
	return _npstat.DoubleArchivedNtuple_rowsPerBuffer(self)

	def writesByColumn(self) -> "bool":
	return _npstat.DoubleArchivedNtuple_writesByColumn(self)

	def isReadable(self) -> "bool":
	return _npstat.DoubleArchivedNtuple_isReadable(self)

	def isWritable(self) -> "bool":
	return _npstat.DoubleArchivedNtuple_isWritable(self)

	def objectNumber(self) -> "unsigned long":
	return _npstat.DoubleArchivedNtuple_objectNumber(self)

	def fill(self, *args) -> "void":
	return _npstat.DoubleArchivedNtuple_fill(self, *args)

	def nRows(self) -> "unsigned long":
	return _npstat.DoubleArchivedNtuple_nRows(self)

	def __call__(self, row: 'unsigned long const', column: 'unsigned long const') -> "double":
	return _npstat.DoubleArchivedNtuple___call__(self, row, column)

	def at(self, row: 'unsigned long const', column: 'unsigned long const') -> "double":
	return _npstat.DoubleArchivedNtuple_at(self, row, column)

	def rowContents(self, row: 'unsigned long const', buffer: 'double *', lenBuffer: 'unsigned long') -> "void":
	return _npstat.DoubleArchivedNtuple_rowContents(self, row, buffer, lenBuffer)

	def columnContents(self, c: 'Column', buffer: 'double *', lenBuffer: 'unsigned long') -> "void":
	return _npstat.DoubleArchivedNtuple_columnContents(self, c, buffer, lenBuffer)

	def clear(self) -> "void":
	return _npstat.DoubleArchivedNtuple_clear(self)

	def write(self) -> "bool":
	return _npstat.DoubleArchivedNtuple_write(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleArchivedNtuple_classId(self)
	if _newclass:
	classname = staticmethod(_npstat.DoubleArchivedNtuple_classname)
	else:
	classname = _npstat.DoubleArchivedNtuple_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleArchivedNtuple_version)
	else:
	version = _npstat.DoubleArchivedNtuple_version
	DoubleArchivedNtuple_swigregister = _npstat.DoubleArchivedNtuple_swigregister
	DoubleArchivedNtuple_swigregister(DoubleArchivedNtuple)

	def DoubleArchivedNtuple_classname() -> "char const *":
	return _npstat.DoubleArchivedNtuple_classname()
	DoubleArchivedNtuple_classname = _npstat.DoubleArchivedNtuple_classname

	def DoubleArchivedNtuple_version() -> "unsigned int":
	return _npstat.DoubleArchivedNtuple_version()
	DoubleArchivedNtuple_version = _npstat.DoubleArchivedNtuple_version

	class AbsPolyFilter1D(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsPolyFilter1D, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, AbsPolyFilter1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsPolyFilter1D
	__del__ = lambda self: None

	def dataLen(self) -> "unsigned int":
	return _npstat.AbsPolyFilter1D_dataLen(self)

	def selfContribution(self, index: 'unsigned int') -> "double":
	return _npstat.AbsPolyFilter1D_selfContribution(self, index)
	AbsPolyFilter1D_swigregister = _npstat.AbsPolyFilter1D_swigregister
	AbsPolyFilter1D_swigregister(AbsPolyFilter1D)

	class UCharFunctor0(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharFunctor0, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharFunctor0, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_UCharFunctor0
	__del__ = lambda self: None

	def __call__(self) -> "unsigned char":
	return _npstat.UCharFunctor0___call__(self)
	UCharFunctor0_swigregister = _npstat.UCharFunctor0_swigregister
	UCharFunctor0_swigregister(UCharFunctor0)

	class IntFunctor0(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntFunctor0, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntFunctor0, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_IntFunctor0
	__del__ = lambda self: None

	def __call__(self) -> "int":
	return _npstat.IntFunctor0___call__(self)
	IntFunctor0_swigregister = _npstat.IntFunctor0_swigregister
	IntFunctor0_swigregister(IntFunctor0)

	class LLongFunctor0(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongFunctor0, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongFunctor0, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LLongFunctor0
	__del__ = lambda self: None

	def __call__(self) -> "long long":
	return _npstat.LLongFunctor0___call__(self)
	LLongFunctor0_swigregister = _npstat.LLongFunctor0_swigregister
	LLongFunctor0_swigregister(LLongFunctor0)

	class FloatFunctor0(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatFunctor0, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatFunctor0, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatFunctor0
	__del__ = lambda self: None

	def __call__(self) -> "float":
	return _npstat.FloatFunctor0___call__(self)
	FloatFunctor0_swigregister = _npstat.FloatFunctor0_swigregister
	FloatFunctor0_swigregister(FloatFunctor0)

	class DoubleFunctor0(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleFunctor0, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleFunctor0, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleFunctor0
	__del__ = lambda self: None

	def __call__(self) -> "double":
	return _npstat.DoubleFunctor0___call__(self)
	DoubleFunctor0_swigregister = _npstat.DoubleFunctor0_swigregister
	DoubleFunctor0_swigregister(DoubleFunctor0)

	class UCharFcnFunctor0(UCharFunctor0):
	__swig_setmethods__ = {}
	for _s in [UCharFunctor0]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharFcnFunctor0, name, value)
	__swig_getmethods__ = {}
	for _s in [UCharFunctor0]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UCharFcnFunctor0, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'unsigned char (*)()'):
	this = _npstat.new_UCharFcnFunctor0(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UCharFcnFunctor0
	__del__ = lambda self: None

	def __call__(self) -> "unsigned char":
	return _npstat.UCharFcnFunctor0___call__(self)

	def __eq__(self, r: 'UCharFcnFunctor0') -> "bool":
	return _npstat.UCharFcnFunctor0___eq__(self, r)

	def __ne__(self, r: 'UCharFcnFunctor0') -> "bool":
	return _npstat.UCharFcnFunctor0___ne__(self, r)
	UCharFcnFunctor0_swigregister = _npstat.UCharFcnFunctor0_swigregister
	UCharFcnFunctor0_swigregister(UCharFcnFunctor0)

	class IntFcnFunctor0(IntFunctor0):
	__swig_setmethods__ = {}
	for _s in [IntFunctor0]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntFcnFunctor0, name, value)
	__swig_getmethods__ = {}
	for _s in [IntFunctor0]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, IntFcnFunctor0, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'int (*)()'):
	this = _npstat.new_IntFcnFunctor0(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_IntFcnFunctor0
	__del__ = lambda self: None

	def __call__(self) -> "int":
	return _npstat.IntFcnFunctor0___call__(self)

	def __eq__(self, r: 'IntFcnFunctor0') -> "bool":
	return _npstat.IntFcnFunctor0___eq__(self, r)

	def __ne__(self, r: 'IntFcnFunctor0') -> "bool":
	return _npstat.IntFcnFunctor0___ne__(self, r)
	IntFcnFunctor0_swigregister = _npstat.IntFcnFunctor0_swigregister
	IntFcnFunctor0_swigregister(IntFcnFunctor0)

	class LLongFcnFunctor0(LLongFunctor0):
	__swig_setmethods__ = {}
	for _s in [LLongFunctor0]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongFcnFunctor0, name, value)
	__swig_getmethods__ = {}
	for _s in [LLongFunctor0]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LLongFcnFunctor0, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'long long (*)()'):
	this = _npstat.new_LLongFcnFunctor0(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_LLongFcnFunctor0
	__del__ = lambda self: None

	def __call__(self) -> "long long":
	return _npstat.LLongFcnFunctor0___call__(self)

	def __eq__(self, r: 'LLongFcnFunctor0') -> "bool":
	return _npstat.LLongFcnFunctor0___eq__(self, r)

	def __ne__(self, r: 'LLongFcnFunctor0') -> "bool":
	return _npstat.LLongFcnFunctor0___ne__(self, r)
	LLongFcnFunctor0_swigregister = _npstat.LLongFcnFunctor0_swigregister
	LLongFcnFunctor0_swigregister(LLongFcnFunctor0)

	class FloatFcnFunctor0(FloatFunctor0):
	__swig_setmethods__ = {}
	for _s in [FloatFunctor0]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatFcnFunctor0, name, value)
	__swig_getmethods__ = {}
	for _s in [FloatFunctor0]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatFcnFunctor0, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'float (*)()'):
	this = _npstat.new_FloatFcnFunctor0(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatFcnFunctor0
	__del__ = lambda self: None

	def __call__(self) -> "float":
	return _npstat.FloatFcnFunctor0___call__(self)

	def __eq__(self, r: 'FloatFcnFunctor0') -> "bool":
	return _npstat.FloatFcnFunctor0___eq__(self, r)

	def __ne__(self, r: 'FloatFcnFunctor0') -> "bool":
	return _npstat.FloatFcnFunctor0___ne__(self, r)
	FloatFcnFunctor0_swigregister = _npstat.FloatFcnFunctor0_swigregister
	FloatFcnFunctor0_swigregister(FloatFcnFunctor0)

	class DoubleFcnFunctor0(DoubleFunctor0):
	__swig_setmethods__ = {}
	for _s in [DoubleFunctor0]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleFcnFunctor0, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleFunctor0]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleFcnFunctor0, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'double (*)()'):
	this = _npstat.new_DoubleFcnFunctor0(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleFcnFunctor0
	__del__ = lambda self: None

	def __call__(self) -> "double":
	return _npstat.DoubleFcnFunctor0___call__(self)

	def __eq__(self, r: 'DoubleFcnFunctor0') -> "bool":
	return _npstat.DoubleFcnFunctor0___eq__(self, r)

	def __ne__(self, r: 'DoubleFcnFunctor0') -> "bool":
	return _npstat.DoubleFcnFunctor0___ne__(self, r)
	DoubleFcnFunctor0_swigregister = _npstat.DoubleFcnFunctor0_swigregister
	DoubleFcnFunctor0_swigregister(DoubleFcnFunctor0)

	class UCharUCharFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharUCharFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharUCharFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_UCharUCharFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'unsigned char const &') -> "unsigned char":
	return _npstat.UCharUCharFunctor1___call__(self, arg2)
	UCharUCharFunctor1_swigregister = _npstat.UCharUCharFunctor1_swigregister
	UCharUCharFunctor1_swigregister(UCharUCharFunctor1)

	class UCharIntFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharIntFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharIntFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_UCharIntFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'int const &') -> "unsigned char":
	return _npstat.UCharIntFunctor1___call__(self, arg2)
	UCharIntFunctor1_swigregister = _npstat.UCharIntFunctor1_swigregister
	UCharIntFunctor1_swigregister(UCharIntFunctor1)

	class UCharLLongFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharLLongFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharLLongFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_UCharLLongFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'long long const &') -> "unsigned char":
	return _npstat.UCharLLongFunctor1___call__(self, arg2)
	UCharLLongFunctor1_swigregister = _npstat.UCharLLongFunctor1_swigregister
	UCharLLongFunctor1_swigregister(UCharLLongFunctor1)

	class UCharFloatFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharFloatFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharFloatFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_UCharFloatFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'float const &') -> "unsigned char":
	return _npstat.UCharFloatFunctor1___call__(self, arg2)
	UCharFloatFunctor1_swigregister = _npstat.UCharFloatFunctor1_swigregister
	UCharFloatFunctor1_swigregister(UCharFloatFunctor1)

	class UCharDoubleFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharDoubleFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharDoubleFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_UCharDoubleFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'double const &') -> "unsigned char":
	return _npstat.UCharDoubleFunctor1___call__(self, arg2)
	UCharDoubleFunctor1_swigregister = _npstat.UCharDoubleFunctor1_swigregister
	UCharDoubleFunctor1_swigregister(UCharDoubleFunctor1)

	class IntUCharFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntUCharFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntUCharFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_IntUCharFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'unsigned char const &') -> "int":
	return _npstat.IntUCharFunctor1___call__(self, arg2)
	IntUCharFunctor1_swigregister = _npstat.IntUCharFunctor1_swigregister
	IntUCharFunctor1_swigregister(IntUCharFunctor1)

	class IntIntFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntIntFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntIntFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_IntIntFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'int const &') -> "int":
	return _npstat.IntIntFunctor1___call__(self, arg2)
	IntIntFunctor1_swigregister = _npstat.IntIntFunctor1_swigregister
	IntIntFunctor1_swigregister(IntIntFunctor1)

	class IntLLongFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntLLongFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntLLongFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_IntLLongFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'long long const &') -> "int":
	return _npstat.IntLLongFunctor1___call__(self, arg2)
	IntLLongFunctor1_swigregister = _npstat.IntLLongFunctor1_swigregister
	IntLLongFunctor1_swigregister(IntLLongFunctor1)

	class IntFloatFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntFloatFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntFloatFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_IntFloatFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'float const &') -> "int":
	return _npstat.IntFloatFunctor1___call__(self, arg2)
	IntFloatFunctor1_swigregister = _npstat.IntFloatFunctor1_swigregister
	IntFloatFunctor1_swigregister(IntFloatFunctor1)

	class IntDoubleFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntDoubleFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntDoubleFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_IntDoubleFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'double const &') -> "int":
	return _npstat.IntDoubleFunctor1___call__(self, arg2)
	IntDoubleFunctor1_swigregister = _npstat.IntDoubleFunctor1_swigregister
	IntDoubleFunctor1_swigregister(IntDoubleFunctor1)

	class LLongUCharFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongUCharFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongUCharFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LLongUCharFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'unsigned char const &') -> "long long":
	return _npstat.LLongUCharFunctor1___call__(self, arg2)
	LLongUCharFunctor1_swigregister = _npstat.LLongUCharFunctor1_swigregister
	LLongUCharFunctor1_swigregister(LLongUCharFunctor1)

	class LLongIntFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongIntFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongIntFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LLongIntFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'int const &') -> "long long":
	return _npstat.LLongIntFunctor1___call__(self, arg2)
	LLongIntFunctor1_swigregister = _npstat.LLongIntFunctor1_swigregister
	LLongIntFunctor1_swigregister(LLongIntFunctor1)

	class LLongLLongFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongLLongFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongLLongFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LLongLLongFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'long long const &') -> "long long":
	return _npstat.LLongLLongFunctor1___call__(self, arg2)
	LLongLLongFunctor1_swigregister = _npstat.LLongLLongFunctor1_swigregister
	LLongLLongFunctor1_swigregister(LLongLLongFunctor1)

	class LLongFloatFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongFloatFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongFloatFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LLongFloatFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'float const &') -> "long long":
	return _npstat.LLongFloatFunctor1___call__(self, arg2)
	LLongFloatFunctor1_swigregister = _npstat.LLongFloatFunctor1_swigregister
	LLongFloatFunctor1_swigregister(LLongFloatFunctor1)

	class LLongDoubleFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongDoubleFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongDoubleFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LLongDoubleFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'double const &') -> "long long":
	return _npstat.LLongDoubleFunctor1___call__(self, arg2)
	LLongDoubleFunctor1_swigregister = _npstat.LLongDoubleFunctor1_swigregister
	LLongDoubleFunctor1_swigregister(LLongDoubleFunctor1)

	class FloatUCharFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatUCharFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatUCharFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatUCharFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'unsigned char const &') -> "float":
	return _npstat.FloatUCharFunctor1___call__(self, arg2)
	FloatUCharFunctor1_swigregister = _npstat.FloatUCharFunctor1_swigregister
	FloatUCharFunctor1_swigregister(FloatUCharFunctor1)

	class FloatIntFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatIntFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatIntFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatIntFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'int const &') -> "float":
	return _npstat.FloatIntFunctor1___call__(self, arg2)
	FloatIntFunctor1_swigregister = _npstat.FloatIntFunctor1_swigregister
	FloatIntFunctor1_swigregister(FloatIntFunctor1)

	class FloatLLongFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatLLongFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatLLongFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatLLongFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'long long const &') -> "float":
	return _npstat.FloatLLongFunctor1___call__(self, arg2)
	FloatLLongFunctor1_swigregister = _npstat.FloatLLongFunctor1_swigregister
	FloatLLongFunctor1_swigregister(FloatLLongFunctor1)

	class FloatFloatFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatFloatFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatFloatFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatFloatFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'float const &') -> "float":
	return _npstat.FloatFloatFunctor1___call__(self, arg2)
	FloatFloatFunctor1_swigregister = _npstat.FloatFloatFunctor1_swigregister
	FloatFloatFunctor1_swigregister(FloatFloatFunctor1)

	class FloatDoubleFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatDoubleFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatDoubleFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatDoubleFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'double const &') -> "float":
	return _npstat.FloatDoubleFunctor1___call__(self, arg2)
	FloatDoubleFunctor1_swigregister = _npstat.FloatDoubleFunctor1_swigregister
	FloatDoubleFunctor1_swigregister(FloatDoubleFunctor1)

	class DoubleUCharFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleUCharFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleUCharFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleUCharFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'unsigned char const &') -> "double":
	return _npstat.DoubleUCharFunctor1___call__(self, arg2)
	DoubleUCharFunctor1_swigregister = _npstat.DoubleUCharFunctor1_swigregister
	DoubleUCharFunctor1_swigregister(DoubleUCharFunctor1)

	class DoubleIntFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleIntFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleIntFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleIntFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'int const &') -> "double":
	return _npstat.DoubleIntFunctor1___call__(self, arg2)
	DoubleIntFunctor1_swigregister = _npstat.DoubleIntFunctor1_swigregister
	DoubleIntFunctor1_swigregister(DoubleIntFunctor1)

	class DoubleLLongFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleLLongFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleLLongFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleLLongFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'long long const &') -> "double":
	return _npstat.DoubleLLongFunctor1___call__(self, arg2)
	DoubleLLongFunctor1_swigregister = _npstat.DoubleLLongFunctor1_swigregister
	DoubleLLongFunctor1_swigregister(DoubleLLongFunctor1)

	class DoubleFloatFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleFloatFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleFloatFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleFloatFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'float const &') -> "double":
	return _npstat.DoubleFloatFunctor1___call__(self, arg2)
	DoubleFloatFunctor1_swigregister = _npstat.DoubleFloatFunctor1_swigregister
	DoubleFloatFunctor1_swigregister(DoubleFloatFunctor1)

	class DoubleDoubleFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleDoubleFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleDoubleFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleDoubleFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'double const &') -> "double":
	return _npstat.DoubleDoubleFunctor1___call__(self, arg2)
	DoubleDoubleFunctor1_swigregister = _npstat.DoubleDoubleFunctor1_swigregister
	DoubleDoubleFunctor1_swigregister(DoubleDoubleFunctor1)

	class UCharUCharFcnFunctor1(UCharUCharFunctor1):
	__swig_setmethods__ = {}
	for _s in [UCharUCharFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharUCharFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [UCharUCharFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UCharUCharFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'unsigned char (*)(unsigned char)'):
	this = _npstat.new_UCharUCharFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UCharUCharFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'unsigned char const &') -> "unsigned char":
	return _npstat.UCharUCharFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'UCharUCharFcnFunctor1') -> "bool":
	return _npstat.UCharUCharFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'UCharUCharFcnFunctor1') -> "bool":
	return _npstat.UCharUCharFcnFunctor1___ne__(self, r)
	UCharUCharFcnFunctor1_swigregister = _npstat.UCharUCharFcnFunctor1_swigregister
	UCharUCharFcnFunctor1_swigregister(UCharUCharFcnFunctor1)

	class UCharIntFcnFunctor1(UCharIntFunctor1):
	__swig_setmethods__ = {}
	for _s in [UCharIntFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharIntFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [UCharIntFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UCharIntFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'unsigned char (*)(int)'):
	this = _npstat.new_UCharIntFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UCharIntFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'int const &') -> "unsigned char":
	return _npstat.UCharIntFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'UCharIntFcnFunctor1') -> "bool":
	return _npstat.UCharIntFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'UCharIntFcnFunctor1') -> "bool":
	return _npstat.UCharIntFcnFunctor1___ne__(self, r)
	UCharIntFcnFunctor1_swigregister = _npstat.UCharIntFcnFunctor1_swigregister
	UCharIntFcnFunctor1_swigregister(UCharIntFcnFunctor1)

	class UCharLLongFcnFunctor1(UCharLLongFunctor1):
	__swig_setmethods__ = {}
	for _s in [UCharLLongFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharLLongFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [UCharLLongFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UCharLLongFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'unsigned char (*)(long long)'):
	this = _npstat.new_UCharLLongFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UCharLLongFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'long long const &') -> "unsigned char":
	return _npstat.UCharLLongFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'UCharLLongFcnFunctor1') -> "bool":
	return _npstat.UCharLLongFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'UCharLLongFcnFunctor1') -> "bool":
	return _npstat.UCharLLongFcnFunctor1___ne__(self, r)
	UCharLLongFcnFunctor1_swigregister = _npstat.UCharLLongFcnFunctor1_swigregister
	UCharLLongFcnFunctor1_swigregister(UCharLLongFcnFunctor1)

	class UCharFloatFcnFunctor1(UCharFloatFunctor1):
	__swig_setmethods__ = {}
	for _s in [UCharFloatFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharFloatFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [UCharFloatFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UCharFloatFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'unsigned char (*)(float)'):
	this = _npstat.new_UCharFloatFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UCharFloatFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'float const &') -> "unsigned char":
	return _npstat.UCharFloatFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'UCharFloatFcnFunctor1') -> "bool":
	return _npstat.UCharFloatFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'UCharFloatFcnFunctor1') -> "bool":
	return _npstat.UCharFloatFcnFunctor1___ne__(self, r)
	UCharFloatFcnFunctor1_swigregister = _npstat.UCharFloatFcnFunctor1_swigregister
	UCharFloatFcnFunctor1_swigregister(UCharFloatFcnFunctor1)

	class UCharDoubleFcnFunctor1(UCharDoubleFunctor1):
	__swig_setmethods__ = {}
	for _s in [UCharDoubleFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharDoubleFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [UCharDoubleFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UCharDoubleFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'unsigned char (*)(double)'):
	this = _npstat.new_UCharDoubleFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UCharDoubleFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'double const &') -> "unsigned char":
	return _npstat.UCharDoubleFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'UCharDoubleFcnFunctor1') -> "bool":
	return _npstat.UCharDoubleFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'UCharDoubleFcnFunctor1') -> "bool":
	return _npstat.UCharDoubleFcnFunctor1___ne__(self, r)
	UCharDoubleFcnFunctor1_swigregister = _npstat.UCharDoubleFcnFunctor1_swigregister
	UCharDoubleFcnFunctor1_swigregister(UCharDoubleFcnFunctor1)

	class IntUCharFcnFunctor1(IntUCharFunctor1):
	__swig_setmethods__ = {}
	for _s in [IntUCharFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntUCharFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [IntUCharFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, IntUCharFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'int (*)(unsigned char)'):
	this = _npstat.new_IntUCharFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_IntUCharFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'unsigned char const &') -> "int":
	return _npstat.IntUCharFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'IntUCharFcnFunctor1') -> "bool":
	return _npstat.IntUCharFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'IntUCharFcnFunctor1') -> "bool":
	return _npstat.IntUCharFcnFunctor1___ne__(self, r)
	IntUCharFcnFunctor1_swigregister = _npstat.IntUCharFcnFunctor1_swigregister
	IntUCharFcnFunctor1_swigregister(IntUCharFcnFunctor1)

	class IntIntFcnFunctor1(IntIntFunctor1):
	__swig_setmethods__ = {}
	for _s in [IntIntFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntIntFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [IntIntFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, IntIntFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'int (*)(int)'):
	this = _npstat.new_IntIntFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_IntIntFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'int const &') -> "int":
	return _npstat.IntIntFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'IntIntFcnFunctor1') -> "bool":
	return _npstat.IntIntFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'IntIntFcnFunctor1') -> "bool":
	return _npstat.IntIntFcnFunctor1___ne__(self, r)
	IntIntFcnFunctor1_swigregister = _npstat.IntIntFcnFunctor1_swigregister
	IntIntFcnFunctor1_swigregister(IntIntFcnFunctor1)

	class IntLLongFcnFunctor1(IntLLongFunctor1):
	__swig_setmethods__ = {}
	for _s in [IntLLongFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntLLongFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [IntLLongFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, IntLLongFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'int (*)(long long)'):
	this = _npstat.new_IntLLongFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_IntLLongFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'long long const &') -> "int":
	return _npstat.IntLLongFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'IntLLongFcnFunctor1') -> "bool":
	return _npstat.IntLLongFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'IntLLongFcnFunctor1') -> "bool":
	return _npstat.IntLLongFcnFunctor1___ne__(self, r)
	IntLLongFcnFunctor1_swigregister = _npstat.IntLLongFcnFunctor1_swigregister
	IntLLongFcnFunctor1_swigregister(IntLLongFcnFunctor1)

	class IntFloatFcnFunctor1(IntFloatFunctor1):
	__swig_setmethods__ = {}
	for _s in [IntFloatFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntFloatFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [IntFloatFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, IntFloatFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'int (*)(float)'):
	this = _npstat.new_IntFloatFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_IntFloatFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'float const &') -> "int":
	return _npstat.IntFloatFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'IntFloatFcnFunctor1') -> "bool":
	return _npstat.IntFloatFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'IntFloatFcnFunctor1') -> "bool":
	return _npstat.IntFloatFcnFunctor1___ne__(self, r)
	IntFloatFcnFunctor1_swigregister = _npstat.IntFloatFcnFunctor1_swigregister
	IntFloatFcnFunctor1_swigregister(IntFloatFcnFunctor1)

	class IntDoubleFcnFunctor1(IntDoubleFunctor1):
	__swig_setmethods__ = {}
	for _s in [IntDoubleFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntDoubleFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [IntDoubleFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, IntDoubleFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'int (*)(double)'):
	this = _npstat.new_IntDoubleFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_IntDoubleFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'double const &') -> "int":
	return _npstat.IntDoubleFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'IntDoubleFcnFunctor1') -> "bool":
	return _npstat.IntDoubleFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'IntDoubleFcnFunctor1') -> "bool":
	return _npstat.IntDoubleFcnFunctor1___ne__(self, r)
	IntDoubleFcnFunctor1_swigregister = _npstat.IntDoubleFcnFunctor1_swigregister
	IntDoubleFcnFunctor1_swigregister(IntDoubleFcnFunctor1)

	class LLongUCharFcnFunctor1(LLongUCharFunctor1):
	__swig_setmethods__ = {}
	for _s in [LLongUCharFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongUCharFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [LLongUCharFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LLongUCharFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'long long (*)(unsigned char)'):
	this = _npstat.new_LLongUCharFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_LLongUCharFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'unsigned char const &') -> "long long":
	return _npstat.LLongUCharFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'LLongUCharFcnFunctor1') -> "bool":
	return _npstat.LLongUCharFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'LLongUCharFcnFunctor1') -> "bool":
	return _npstat.LLongUCharFcnFunctor1___ne__(self, r)
	LLongUCharFcnFunctor1_swigregister = _npstat.LLongUCharFcnFunctor1_swigregister
	LLongUCharFcnFunctor1_swigregister(LLongUCharFcnFunctor1)

	class LLongIntFcnFunctor1(LLongIntFunctor1):
	__swig_setmethods__ = {}
	for _s in [LLongIntFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongIntFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [LLongIntFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LLongIntFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'long long (*)(int)'):
	this = _npstat.new_LLongIntFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_LLongIntFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'int const &') -> "long long":
	return _npstat.LLongIntFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'LLongIntFcnFunctor1') -> "bool":
	return _npstat.LLongIntFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'LLongIntFcnFunctor1') -> "bool":
	return _npstat.LLongIntFcnFunctor1___ne__(self, r)
	LLongIntFcnFunctor1_swigregister = _npstat.LLongIntFcnFunctor1_swigregister
	LLongIntFcnFunctor1_swigregister(LLongIntFcnFunctor1)

	class LLongLLongFcnFunctor1(LLongLLongFunctor1):
	__swig_setmethods__ = {}
	for _s in [LLongLLongFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongLLongFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [LLongLLongFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LLongLLongFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'long long (*)(long long)'):
	this = _npstat.new_LLongLLongFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_LLongLLongFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'long long const &') -> "long long":
	return _npstat.LLongLLongFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'LLongLLongFcnFunctor1') -> "bool":
	return _npstat.LLongLLongFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'LLongLLongFcnFunctor1') -> "bool":
	return _npstat.LLongLLongFcnFunctor1___ne__(self, r)
	LLongLLongFcnFunctor1_swigregister = _npstat.LLongLLongFcnFunctor1_swigregister
	LLongLLongFcnFunctor1_swigregister(LLongLLongFcnFunctor1)

	class LLongFloatFcnFunctor1(LLongFloatFunctor1):
	__swig_setmethods__ = {}
	for _s in [LLongFloatFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongFloatFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [LLongFloatFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LLongFloatFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'long long (*)(float)'):
	this = _npstat.new_LLongFloatFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_LLongFloatFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'float const &') -> "long long":
	return _npstat.LLongFloatFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'LLongFloatFcnFunctor1') -> "bool":
	return _npstat.LLongFloatFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'LLongFloatFcnFunctor1') -> "bool":
	return _npstat.LLongFloatFcnFunctor1___ne__(self, r)
	LLongFloatFcnFunctor1_swigregister = _npstat.LLongFloatFcnFunctor1_swigregister
	LLongFloatFcnFunctor1_swigregister(LLongFloatFcnFunctor1)

	class LLongDoubleFcnFunctor1(LLongDoubleFunctor1):
	__swig_setmethods__ = {}
	for _s in [LLongDoubleFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongDoubleFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [LLongDoubleFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LLongDoubleFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'long long (*)(double)'):
	this = _npstat.new_LLongDoubleFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_LLongDoubleFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'double const &') -> "long long":
	return _npstat.LLongDoubleFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'LLongDoubleFcnFunctor1') -> "bool":
	return _npstat.LLongDoubleFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'LLongDoubleFcnFunctor1') -> "bool":
	return _npstat.LLongDoubleFcnFunctor1___ne__(self, r)
	LLongDoubleFcnFunctor1_swigregister = _npstat.LLongDoubleFcnFunctor1_swigregister
	LLongDoubleFcnFunctor1_swigregister(LLongDoubleFcnFunctor1)

	class FloatUCharFcnFunctor1(FloatUCharFunctor1):
	__swig_setmethods__ = {}
	for _s in [FloatUCharFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatUCharFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [FloatUCharFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatUCharFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'float (*)(unsigned char)'):
	this = _npstat.new_FloatUCharFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatUCharFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'unsigned char const &') -> "float":
	return _npstat.FloatUCharFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'FloatUCharFcnFunctor1') -> "bool":
	return _npstat.FloatUCharFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'FloatUCharFcnFunctor1') -> "bool":
	return _npstat.FloatUCharFcnFunctor1___ne__(self, r)
	FloatUCharFcnFunctor1_swigregister = _npstat.FloatUCharFcnFunctor1_swigregister
	FloatUCharFcnFunctor1_swigregister(FloatUCharFcnFunctor1)

	class FloatIntFcnFunctor1(FloatIntFunctor1):
	__swig_setmethods__ = {}
	for _s in [FloatIntFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatIntFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [FloatIntFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatIntFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'float (*)(int)'):
	this = _npstat.new_FloatIntFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatIntFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'int const &') -> "float":
	return _npstat.FloatIntFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'FloatIntFcnFunctor1') -> "bool":
	return _npstat.FloatIntFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'FloatIntFcnFunctor1') -> "bool":
	return _npstat.FloatIntFcnFunctor1___ne__(self, r)
	FloatIntFcnFunctor1_swigregister = _npstat.FloatIntFcnFunctor1_swigregister
	FloatIntFcnFunctor1_swigregister(FloatIntFcnFunctor1)

	class FloatLLongFcnFunctor1(FloatLLongFunctor1):
	__swig_setmethods__ = {}
	for _s in [FloatLLongFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatLLongFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [FloatLLongFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatLLongFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'float (*)(long long)'):
	this = _npstat.new_FloatLLongFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatLLongFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'long long const &') -> "float":
	return _npstat.FloatLLongFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'FloatLLongFcnFunctor1') -> "bool":
	return _npstat.FloatLLongFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'FloatLLongFcnFunctor1') -> "bool":
	return _npstat.FloatLLongFcnFunctor1___ne__(self, r)
	FloatLLongFcnFunctor1_swigregister = _npstat.FloatLLongFcnFunctor1_swigregister
	FloatLLongFcnFunctor1_swigregister(FloatLLongFcnFunctor1)

	class FloatFloatFcnFunctor1(FloatFloatFunctor1):
	__swig_setmethods__ = {}
	for _s in [FloatFloatFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatFloatFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [FloatFloatFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatFloatFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'float (*)(float)'):
	this = _npstat.new_FloatFloatFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatFloatFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'float const &') -> "float":
	return _npstat.FloatFloatFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'FloatFloatFcnFunctor1') -> "bool":
	return _npstat.FloatFloatFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'FloatFloatFcnFunctor1') -> "bool":
	return _npstat.FloatFloatFcnFunctor1___ne__(self, r)
	FloatFloatFcnFunctor1_swigregister = _npstat.FloatFloatFcnFunctor1_swigregister
	FloatFloatFcnFunctor1_swigregister(FloatFloatFcnFunctor1)

	class FloatDoubleFcnFunctor1(FloatDoubleFunctor1):
	__swig_setmethods__ = {}
	for _s in [FloatDoubleFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatDoubleFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [FloatDoubleFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatDoubleFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'float (*)(double)'):
	this = _npstat.new_FloatDoubleFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatDoubleFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'double const &') -> "float":
	return _npstat.FloatDoubleFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'FloatDoubleFcnFunctor1') -> "bool":
	return _npstat.FloatDoubleFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'FloatDoubleFcnFunctor1') -> "bool":
	return _npstat.FloatDoubleFcnFunctor1___ne__(self, r)
	FloatDoubleFcnFunctor1_swigregister = _npstat.FloatDoubleFcnFunctor1_swigregister
	FloatDoubleFcnFunctor1_swigregister(FloatDoubleFcnFunctor1)

	class DoubleUCharFcnFunctor1(DoubleUCharFunctor1):
	__swig_setmethods__ = {}
	for _s in [DoubleUCharFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleUCharFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleUCharFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleUCharFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'double (*)(unsigned char)'):
	this = _npstat.new_DoubleUCharFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleUCharFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'unsigned char const &') -> "double":
	return _npstat.DoubleUCharFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'DoubleUCharFcnFunctor1') -> "bool":
	return _npstat.DoubleUCharFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'DoubleUCharFcnFunctor1') -> "bool":
	return _npstat.DoubleUCharFcnFunctor1___ne__(self, r)
	DoubleUCharFcnFunctor1_swigregister = _npstat.DoubleUCharFcnFunctor1_swigregister
	DoubleUCharFcnFunctor1_swigregister(DoubleUCharFcnFunctor1)

	class DoubleIntFcnFunctor1(DoubleIntFunctor1):
	__swig_setmethods__ = {}
	for _s in [DoubleIntFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleIntFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleIntFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleIntFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'double (*)(int)'):
	this = _npstat.new_DoubleIntFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleIntFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'int const &') -> "double":
	return _npstat.DoubleIntFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'DoubleIntFcnFunctor1') -> "bool":
	return _npstat.DoubleIntFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'DoubleIntFcnFunctor1') -> "bool":
	return _npstat.DoubleIntFcnFunctor1___ne__(self, r)
	DoubleIntFcnFunctor1_swigregister = _npstat.DoubleIntFcnFunctor1_swigregister
	DoubleIntFcnFunctor1_swigregister(DoubleIntFcnFunctor1)

	class DoubleLLongFcnFunctor1(DoubleLLongFunctor1):
	__swig_setmethods__ = {}
	for _s in [DoubleLLongFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleLLongFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleLLongFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleLLongFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'double (*)(long long)'):
	this = _npstat.new_DoubleLLongFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleLLongFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'long long const &') -> "double":
	return _npstat.DoubleLLongFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'DoubleLLongFcnFunctor1') -> "bool":
	return _npstat.DoubleLLongFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'DoubleLLongFcnFunctor1') -> "bool":
	return _npstat.DoubleLLongFcnFunctor1___ne__(self, r)
	DoubleLLongFcnFunctor1_swigregister = _npstat.DoubleLLongFcnFunctor1_swigregister
	DoubleLLongFcnFunctor1_swigregister(DoubleLLongFcnFunctor1)

	class DoubleFloatFcnFunctor1(DoubleFloatFunctor1):
	__swig_setmethods__ = {}
	for _s in [DoubleFloatFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleFloatFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleFloatFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleFloatFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'double (*)(float)'):
	this = _npstat.new_DoubleFloatFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleFloatFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'float const &') -> "double":
	return _npstat.DoubleFloatFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'DoubleFloatFcnFunctor1') -> "bool":
	return _npstat.DoubleFloatFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'DoubleFloatFcnFunctor1') -> "bool":
	return _npstat.DoubleFloatFcnFunctor1___ne__(self, r)
	DoubleFloatFcnFunctor1_swigregister = _npstat.DoubleFloatFcnFunctor1_swigregister
	DoubleFloatFcnFunctor1_swigregister(DoubleFloatFcnFunctor1)

	class DoubleDoubleFcnFunctor1(DoubleDoubleFunctor1):
	__swig_setmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleDoubleFcnFunctor1, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleDoubleFcnFunctor1, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'double (*)(double)'):
	this = _npstat.new_DoubleDoubleFcnFunctor1(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleDoubleFcnFunctor1
	__del__ = lambda self: None

	def __call__(self, a: 'double const &') -> "double":
	return _npstat.DoubleDoubleFcnFunctor1___call__(self, a)

	def __eq__(self, r: 'DoubleDoubleFcnFunctor1') -> "bool":
	return _npstat.DoubleDoubleFcnFunctor1___eq__(self, r)

	def __ne__(self, r: 'DoubleDoubleFcnFunctor1') -> "bool":
	return _npstat.DoubleDoubleFcnFunctor1___ne__(self, r)
	DoubleDoubleFcnFunctor1_swigregister = _npstat.DoubleDoubleFcnFunctor1_swigregister
	DoubleDoubleFcnFunctor1_swigregister(DoubleDoubleFcnFunctor1)

	class UCharSame(UCharUCharFunctor1):
	__swig_setmethods__ = {}
	for _s in [UCharUCharFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharSame, name, value)
	__swig_getmethods__ = {}
	for _s in [UCharUCharFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UCharSame, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_UCharSame
	__del__ = lambda self: None

	def __call__(self, a: 'unsigned char const &') -> "unsigned char":
	return _npstat.UCharSame___call__(self, a)

	def __eq__(self, arg2: 'UCharSame') -> "bool":
	return _npstat.UCharSame___eq__(self, arg2)

	def __ne__(self, arg2: 'UCharSame') -> "bool":
	return _npstat.UCharSame___ne__(self, arg2)

	def __init__(self):
	this = _npstat.new_UCharSame()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	UCharSame_swigregister = _npstat.UCharSame_swigregister
	UCharSame_swigregister(UCharSame)

	class IntSame(IntIntFunctor1):
	__swig_setmethods__ = {}
	for _s in [IntIntFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntSame, name, value)
	__swig_getmethods__ = {}
	for _s in [IntIntFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, IntSame, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_IntSame
	__del__ = lambda self: None

	def __call__(self, a: 'int const &') -> "int":
	return _npstat.IntSame___call__(self, a)

	def __eq__(self, arg2: 'IntSame') -> "bool":
	return _npstat.IntSame___eq__(self, arg2)

	def __ne__(self, arg2: 'IntSame') -> "bool":
	return _npstat.IntSame___ne__(self, arg2)

	def __init__(self):
	this = _npstat.new_IntSame()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	IntSame_swigregister = _npstat.IntSame_swigregister
	IntSame_swigregister(IntSame)

	class LLongSame(LLongLLongFunctor1):
	__swig_setmethods__ = {}
	for _s in [LLongLLongFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongSame, name, value)
	__swig_getmethods__ = {}
	for _s in [LLongLLongFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LLongSame, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LLongSame
	__del__ = lambda self: None

	def __call__(self, a: 'long long const &') -> "long long":
	return _npstat.LLongSame___call__(self, a)

	def __eq__(self, arg2: 'LLongSame') -> "bool":
	return _npstat.LLongSame___eq__(self, arg2)

	def __ne__(self, arg2: 'LLongSame') -> "bool":
	return _npstat.LLongSame___ne__(self, arg2)

	def __init__(self):
	this = _npstat.new_LLongSame()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	LLongSame_swigregister = _npstat.LLongSame_swigregister
	LLongSame_swigregister(LLongSame)

	class FloatSame(FloatFloatFunctor1):
	__swig_setmethods__ = {}
	for _s in [FloatFloatFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatSame, name, value)
	__swig_getmethods__ = {}
	for _s in [FloatFloatFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatSame, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatSame
	__del__ = lambda self: None

	def __call__(self, a: 'float const &') -> "float":
	return _npstat.FloatSame___call__(self, a)

	def __eq__(self, arg2: 'FloatSame') -> "bool":
	return _npstat.FloatSame___eq__(self, arg2)

	def __ne__(self, arg2: 'FloatSame') -> "bool":
	return _npstat.FloatSame___ne__(self, arg2)

	def __init__(self):
	this = _npstat.new_FloatSame()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	FloatSame_swigregister = _npstat.FloatSame_swigregister
	FloatSame_swigregister(FloatSame)

	class DoubleSame(DoubleDoubleFunctor1):
	__swig_setmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleSame, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleSame, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleSame
	__del__ = lambda self: None

	def __call__(self, a: 'double const &') -> "double":
	return _npstat.DoubleSame___call__(self, a)

	def __eq__(self, arg2: 'DoubleSame') -> "bool":
	return _npstat.DoubleSame___eq__(self, arg2)

	def __ne__(self, arg2: 'DoubleSame') -> "bool":
	return _npstat.DoubleSame___ne__(self, arg2)

	def __init__(self):
	this = _npstat.new_DoubleSame()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	DoubleSame_swigregister = _npstat.DoubleSame_swigregister
	DoubleSame_swigregister(DoubleSame)

	class LongDoubleLongDoubleFunctor1(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LongDoubleLongDoubleFunctor1, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LongDoubleLongDoubleFunctor1, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LongDoubleLongDoubleFunctor1
	__del__ = lambda self: None

	def __call__(self, arg2: 'long double const &') -> "long double":
	return _npstat.LongDoubleLongDoubleFunctor1___call__(self, arg2)
	LongDoubleLongDoubleFunctor1_swigregister = _npstat.LongDoubleLongDoubleFunctor1_swigregister
	LongDoubleLongDoubleFunctor1_swigregister(LongDoubleLongDoubleFunctor1)

	class DoubleDoubleDoubleFunctor2(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleDoubleDoubleFunctor2, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleDoubleDoubleFunctor2, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleDoubleDoubleFunctor2
	__del__ = lambda self: None

	def __call__(self, arg2: 'double const &', arg3: 'double const &') -> "double":
	return _npstat.DoubleDoubleDoubleFunctor2___call__(self, arg2, arg3)
	DoubleDoubleDoubleFunctor2_swigregister = _npstat.DoubleDoubleDoubleFunctor2_swigregister
	DoubleDoubleDoubleFunctor2_swigregister(DoubleDoubleDoubleFunctor2)

	class DoubleDoubleDoubleFcnFunctor2(DoubleDoubleDoubleFunctor2):
	__swig_setmethods__ = {}
	for _s in [DoubleDoubleDoubleFunctor2]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleDoubleDoubleFcnFunctor2, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleDoubleDoubleFunctor2]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleDoubleDoubleFcnFunctor2, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'double (*)(double,double)'):
	this = _npstat.new_DoubleDoubleDoubleFcnFunctor2(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleDoubleDoubleFcnFunctor2
	__del__ = lambda self: None

	def __call__(self, x: 'double const &', y: 'double const &') -> "double":
	return _npstat.DoubleDoubleDoubleFcnFunctor2___call__(self, x, y)

	def __eq__(self, r: 'DoubleDoubleDoubleFcnFunctor2') -> "bool":
	return _npstat.DoubleDoubleDoubleFcnFunctor2___eq__(self, r)

	def __ne__(self, r: 'DoubleDoubleDoubleFcnFunctor2') -> "bool":
	return _npstat.DoubleDoubleDoubleFcnFunctor2___ne__(self, r)
	DoubleDoubleDoubleFcnFunctor2_swigregister = _npstat.DoubleDoubleDoubleFcnFunctor2_swigregister
	DoubleDoubleDoubleFcnFunctor2_swigregister(DoubleDoubleDoubleFcnFunctor2)

	class AbsDistribution1D(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsDistribution1D, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, AbsDistribution1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsDistribution1D
	__del__ = lambda self: None

	def density(self, x: 'double') -> "double":
	return _npstat.AbsDistribution1D_density(self, x)

	def cdf(self, x: 'double') -> "double":
	return _npstat.AbsDistribution1D_cdf(self, x)

	def exceedance(self, x: 'double') -> "double":
	return _npstat.AbsDistribution1D_exceedance(self, x)

	def quantile(self, x: 'double') -> "double":
	return _npstat.AbsDistribution1D_quantile(self, x)

	def __eq__(self, r: 'AbsDistribution1D') -> "bool":
	return _npstat.AbsDistribution1D___eq__(self, r)

	def __ne__(self, r: 'AbsDistribution1D') -> "bool":
	return _npstat.AbsDistribution1D___ne__(self, r)

	def clone(self) -> "npstat::AbsDistribution1D *":
	return _npstat.AbsDistribution1D_clone(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.AbsDistribution1D_classId(self)

	def write(self, arg2: 'ostream') -> "bool":
	return _npstat.AbsDistribution1D_write(self, arg2)
	if _newclass:
	classname = staticmethod(_npstat.AbsDistribution1D_classname)
	else:
	classname = _npstat.AbsDistribution1D_classname
	if _newclass:
	version = staticmethod(_npstat.AbsDistribution1D_version)
	else:
	version = _npstat.AbsDistribution1D_version
	if _newclass:
	read = staticmethod(_npstat.AbsDistribution1D_read)
	else:
	read = _npstat.AbsDistribution1D_read

	def random(self, g: 'AbsRandomGenerator') -> "double":
	return _npstat.AbsDistribution1D_random(self, g)

	def generate(self, g: 'AbsRandomGenerator', npoints: 'unsigned int') -> "std::vector< double,std::allocator< double > >":
	return _npstat.AbsDistribution1D_generate(self, g, npoints)
	AbsDistribution1D_swigregister = _npstat.AbsDistribution1D_swigregister
	AbsDistribution1D_swigregister(AbsDistribution1D)

	def AbsDistribution1D_classname() -> "char const *":
	return _npstat.AbsDistribution1D_classname()
	AbsDistribution1D_classname = _npstat.AbsDistribution1D_classname

	def AbsDistribution1D_version() -> "unsigned int":
	return _npstat.AbsDistribution1D_version()
	AbsDistribution1D_version = _npstat.AbsDistribution1D_version

	def AbsDistribution1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::AbsDistribution1D *":
	return _npstat.AbsDistribution1D_read(id, arg3)
	AbsDistribution1D_read = _npstat.AbsDistribution1D_read

	class AbsScalableDistribution1D(AbsDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsScalableDistribution1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, AbsScalableDistribution1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsScalableDistribution1D
	__del__ = lambda self: None

	def location(self) -> "double":
	return _npstat.AbsScalableDistribution1D_location(self)

	def scale(self) -> "double":
	return _npstat.AbsScalableDistribution1D_scale(self)

	def setLocation(self, v: 'double const') -> "void":
	return _npstat.AbsScalableDistribution1D_setLocation(self, v)

	def setScale(self, v: 'double const') -> "void":
	return _npstat.AbsScalableDistribution1D_setScale(self, v)

	def density(self, x: 'double const') -> "double":
	return _npstat.AbsScalableDistribution1D_density(self, x)

	def cdf(self, x: 'double const') -> "double":
	return _npstat.AbsScalableDistribution1D_cdf(self, x)

	def exceedance(self, x: 'double const') -> "double":
	return _npstat.AbsScalableDistribution1D_exceedance(self, x)

	def quantile(self, x: 'double const') -> "double":
	return _npstat.AbsScalableDistribution1D_quantile(self, x)

	def clone(self) -> "npstat::AbsScalableDistribution1D *":
	return _npstat.AbsScalableDistribution1D_clone(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.AbsScalableDistribution1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.AbsScalableDistribution1D_write(self, os)
	if _newclass:
	read = staticmethod(_npstat.AbsScalableDistribution1D_read)
	else:
	read = _npstat.AbsScalableDistribution1D_read
	AbsScalableDistribution1D_swigregister = _npstat.AbsScalableDistribution1D_swigregister
	AbsScalableDistribution1D_swigregister(AbsScalableDistribution1D)

	def AbsScalableDistribution1D_read(arg2: 'istream', location: 'double ', scale: 'double ') -> "bool":
	return _npstat.AbsScalableDistribution1D_read(arg2, location, scale)
	AbsScalableDistribution1D_read = _npstat.AbsScalableDistribution1D_read

	class DensityFunctor1D(DoubleDoubleFunctor1):
	__swig_setmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DensityFunctor1D, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DensityFunctor1D, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistribution1D', normfactor: 'double const'=1.0):
	this = _npstat.new_DensityFunctor1D(fcn, normfactor)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DensityFunctor1D
	__del__ = lambda self: None

	def __call__(self, a: 'double const &') -> "double":
	return _npstat.DensityFunctor1D___call__(self, a)
	DensityFunctor1D_swigregister = _npstat.DensityFunctor1D_swigregister
	DensityFunctor1D_swigregister(DensityFunctor1D)

	class DensitySquaredFunctor1D(DoubleDoubleFunctor1):
	__swig_setmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DensitySquaredFunctor1D, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DensitySquaredFunctor1D, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistribution1D', normfactor: 'double const'=1.0):
	this = _npstat.new_DensitySquaredFunctor1D(fcn, normfactor)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DensitySquaredFunctor1D
	__del__ = lambda self: None

	def __call__(self, a: 'double const &') -> "double":
	return _npstat.DensitySquaredFunctor1D___call__(self, a)
	DensitySquaredFunctor1D_swigregister = _npstat.DensitySquaredFunctor1D_swigregister
	DensitySquaredFunctor1D_swigregister(DensitySquaredFunctor1D)

	class CdfFunctor1D(DoubleDoubleFunctor1):
	__swig_setmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, CdfFunctor1D, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, CdfFunctor1D, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistribution1D', normfactor: 'double const'=1.0):
	this = _npstat.new_CdfFunctor1D(fcn, normfactor)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_CdfFunctor1D
	__del__ = lambda self: None

	def __call__(self, a: 'double const &') -> "double":
	return _npstat.CdfFunctor1D___call__(self, a)
	CdfFunctor1D_swigregister = _npstat.CdfFunctor1D_swigregister
	CdfFunctor1D_swigregister(CdfFunctor1D)

	class ExceedanceFunctor1D(DoubleDoubleFunctor1):
	__swig_setmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ExceedanceFunctor1D, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ExceedanceFunctor1D, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistribution1D', normfactor: 'double const'=1.0):
	this = _npstat.new_ExceedanceFunctor1D(fcn, normfactor)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ExceedanceFunctor1D
	__del__ = lambda self: None

	def __call__(self, a: 'double const &') -> "double":
	return _npstat.ExceedanceFunctor1D___call__(self, a)
	ExceedanceFunctor1D_swigregister = _npstat.ExceedanceFunctor1D_swigregister
	ExceedanceFunctor1D_swigregister(ExceedanceFunctor1D)

	class QuantileFunctor1D(DoubleDoubleFunctor1):
	__swig_setmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, QuantileFunctor1D, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, QuantileFunctor1D, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistribution1D', normfactor: 'double const'=1.0):
	this = _npstat.new_QuantileFunctor1D(fcn, normfactor)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_QuantileFunctor1D
	__del__ = lambda self: None

	def __call__(self, a: 'double const &') -> "double":
	return _npstat.QuantileFunctor1D___call__(self, a)
	QuantileFunctor1D_swigregister = _npstat.QuantileFunctor1D_swigregister
	QuantileFunctor1D_swigregister(QuantileFunctor1D)

	class ArchiveRecord_AbsDistribution1D(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_AbsDistribution1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_AbsDistribution1D, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'AbsDistribution1D', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_AbsDistribution1D(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_AbsDistribution1D
	__del__ = lambda self: None
	ArchiveRecord_AbsDistribution1D_swigregister = _npstat.ArchiveRecord_AbsDistribution1D_swigregister
	ArchiveRecord_AbsDistribution1D_swigregister(ArchiveRecord_AbsDistribution1D)

	class AbsKDE1DKernel(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsKDE1DKernel, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, AbsKDE1DKernel, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsKDE1DKernel
	__del__ = lambda self: None

	def xmin(self) -> "double":
	return _npstat.AbsKDE1DKernel_xmin(self)

	def xmax(self) -> "double":
	return _npstat.AbsKDE1DKernel_xmax(self)

	def __call__(self, x: 'double') -> "double":
	return _npstat.AbsKDE1DKernel___call__(self, x)

	def clone(self) -> "npstat::AbsKDE1DKernel *":
	return _npstat.AbsKDE1DKernel_clone(self)

	def momentIntegral(self, k: 'unsigned int', nIntegPoints: 'unsigned int') -> "double":
	return _npstat.AbsKDE1DKernel_momentIntegral(self, k, nIntegPoints)

	def squaredIntegral(self, nIntegPoints: 'unsigned int') -> "double":
	return _npstat.AbsKDE1DKernel_squaredIntegral(self, nIntegPoints)

	def looKde(self, bandwidth: 'double', nCoords: 'unsigned long', originalDensityEstimate: 'double') -> "double":
	return _npstat.AbsKDE1DKernel_looKde(self, bandwidth, nCoords, originalDensityEstimate)

	def kde(self, x: 'double', bandwidth: 'double', coords: 'double const *', coordinatesSorted: 'bool'=False) -> "double":
	return _npstat.AbsKDE1DKernel_kde(self, x, bandwidth, coords, coordinatesSorted)

	def reverseKde(self, x: 'double', bandwidth: 'double', coords: 'double const *', coordinatesSorted: 'bool'=False) -> "double":
	return _npstat.AbsKDE1DKernel_reverseKde(self, x, bandwidth, coords, coordinatesSorted)

	def integratedSquaredError(self, distro: 'AbsDistribution1D', nIntegIntervals: 'unsigned int', nIntegPoints: 'unsigned int', bandwidth: 'double', useReverseKde: 'bool', coords: 'double const *', coordinatesSorted: 'bool'=False) -> "double":
	return _npstat.AbsKDE1DKernel_integratedSquaredError(self, distro, nIntegIntervals, nIntegPoints, bandwidth, useReverseKde, coords, coordinatesSorted)

	def integratedKdeSquared(self, xmin: 'double', xmax: 'double', nIntegIntervals: 'unsigned int', nIntegPoints: 'unsigned int', bandwidth: 'double', useReverseKde: 'bool', coords: 'double const *', coordinatesSorted: 'bool'=False) -> "double":
	return _npstat.AbsKDE1DKernel_integratedKdeSquared(self, xmin, xmax, nIntegIntervals, nIntegPoints, bandwidth, useReverseKde, coords, coordinatesSorted)
	AbsKDE1DKernel_swigregister = _npstat.AbsKDE1DKernel_swigregister
	AbsKDE1DKernel_swigregister(AbsKDE1DKernel)

	class KDE1DDensityKernel(AbsKDE1DKernel):
	__swig_setmethods__ = {}
	for _s in [AbsKDE1DKernel]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, KDE1DDensityKernel, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsKDE1DKernel]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, KDE1DDensityKernel, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr

	def clone(self) -> "npstat::KDE1DDensityKernel *":
	return _npstat.KDE1DDensityKernel_clone(self)
	__swig_destroy__ = _npstat.delete_KDE1DDensityKernel
	__del__ = lambda self: None

	def xmin(self) -> "double":
	return _npstat.KDE1DDensityKernel_xmin(self)

	def xmax(self) -> "double":
	return _npstat.KDE1DDensityKernel_xmax(self)

	def __call__(self, x: 'double const') -> "double":
	return _npstat.KDE1DDensityKernel___call__(self, x)
	KDE1DDensityKernel_swigregister = _npstat.KDE1DDensityKernel_swigregister
	KDE1DDensityKernel_swigregister(KDE1DDensityKernel)

	class DoubleKDE1DLSCVFunctorHelper(DoubleDoubleFunctor1):
	__swig_setmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleKDE1DLSCVFunctorHelper, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleKDE1DLSCVFunctorHelper, name)
	__repr__ = _swig_repr

	def __init__(self, kernel: 'AbsKDE1DKernel', xmin: 'double const', xmax: 'double const', nIntegIntervals: 'unsigned int const', nIntegPoints: 'unsigned int const', coords: 'double const *', nCoords: 'unsigned long const', coordinatesSorted: 'bool const', useReverseKde: 'bool const'):
	this = _npstat.new_DoubleKDE1DLSCVFunctorHelper(kernel, xmin, xmax, nIntegIntervals, nIntegPoints, coords, nCoords, coordinatesSorted, useReverseKde)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, bw: 'double const &') -> "double":
	return _npstat.DoubleKDE1DLSCVFunctorHelper___call__(self, bw)
	__swig_destroy__ = _npstat.delete_DoubleKDE1DLSCVFunctorHelper
	__del__ = lambda self: None
	DoubleKDE1DLSCVFunctorHelper_swigregister = _npstat.DoubleKDE1DLSCVFunctorHelper_swigregister
	DoubleKDE1DLSCVFunctorHelper_swigregister(DoubleKDE1DLSCVFunctorHelper)

	class DoubleKDE1DRLCVFunctorHelper(DoubleDoubleFunctor1):
	__swig_setmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleKDE1DRLCVFunctorHelper, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleKDE1DRLCVFunctorHelper, name)
	__repr__ = _swig_repr

	def __init__(self, kernel: 'AbsKDE1DKernel', plcvAlpha: 'double const', coords: 'double const *', nCoords: 'unsigned long const', coordinatesSorted: 'bool const', useReverseKde: 'bool const'):
	this = _npstat.new_DoubleKDE1DRLCVFunctorHelper(kernel, plcvAlpha, coords, nCoords, coordinatesSorted, useReverseKde)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, bw: 'double const &') -> "double":
	return _npstat.DoubleKDE1DRLCVFunctorHelper___call__(self, bw)
	__swig_destroy__ = _npstat.delete_DoubleKDE1DRLCVFunctorHelper
	__del__ = lambda self: None
	DoubleKDE1DRLCVFunctorHelper_swigregister = _npstat.DoubleKDE1DRLCVFunctorHelper_swigregister
	DoubleKDE1DRLCVFunctorHelper_swigregister(DoubleKDE1DRLCVFunctorHelper)

	class AbsDiscreteDistribution1D(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsDiscreteDistribution1D, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, AbsDiscreteDistribution1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsDiscreteDistribution1D
	__del__ = lambda self: None

	def probability(self, x: 'long') -> "double":
	return _npstat.AbsDiscreteDistribution1D_probability(self, x)

	def cdf(self, x: 'double') -> "double":
	return _npstat.AbsDiscreteDistribution1D_cdf(self, x)

	def exceedance(self, x: 'double') -> "double":
	return _npstat.AbsDiscreteDistribution1D_exceedance(self, x)

	def quantile(self, x: 'double') -> "long":
	return _npstat.AbsDiscreteDistribution1D_quantile(self, x)

	def __eq__(self, r: 'AbsDiscreteDistribution1D') -> "bool":
	return _npstat.AbsDiscreteDistribution1D___eq__(self, r)

	def __ne__(self, r: 'AbsDiscreteDistribution1D') -> "bool":
	return _npstat.AbsDiscreteDistribution1D___ne__(self, r)

	def clone(self) -> "npstat::AbsDiscreteDistribution1D *":
	return _npstat.AbsDiscreteDistribution1D_clone(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.AbsDiscreteDistribution1D_classId(self)

	def write(self, arg2: 'ostream') -> "bool":
	return _npstat.AbsDiscreteDistribution1D_write(self, arg2)
	if _newclass:
	classname = staticmethod(_npstat.AbsDiscreteDistribution1D_classname)
	else:
	classname = _npstat.AbsDiscreteDistribution1D_classname
	if _newclass:
	version = staticmethod(_npstat.AbsDiscreteDistribution1D_version)
	else:
	version = _npstat.AbsDiscreteDistribution1D_version
	if _newclass:
	read = staticmethod(_npstat.AbsDiscreteDistribution1D_read)
	else:
	read = _npstat.AbsDiscreteDistribution1D_read

	def random(self, g: 'AbsRandomGenerator') -> "long":
	return _npstat.AbsDiscreteDistribution1D_random(self, g)

	def generate(self, g: 'AbsRandomGenerator', npoints: 'unsigned int') -> "std::vector< long,std::allocator< long > >":
	return _npstat.AbsDiscreteDistribution1D_generate(self, g, npoints)
	AbsDiscreteDistribution1D_swigregister = _npstat.AbsDiscreteDistribution1D_swigregister
	AbsDiscreteDistribution1D_swigregister(AbsDiscreteDistribution1D)

	def AbsDiscreteDistribution1D_classname() -> "char const *":
	return _npstat.AbsDiscreteDistribution1D_classname()
	AbsDiscreteDistribution1D_classname = _npstat.AbsDiscreteDistribution1D_classname

	def AbsDiscreteDistribution1D_version() -> "unsigned int":
	return _npstat.AbsDiscreteDistribution1D_version()
	AbsDiscreteDistribution1D_version = _npstat.AbsDiscreteDistribution1D_version

	def AbsDiscreteDistribution1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::AbsDiscreteDistribution1D *":
	return _npstat.AbsDiscreteDistribution1D_read(id, arg3)
	AbsDiscreteDistribution1D_read = _npstat.AbsDiscreteDistribution1D_read

	class ShiftableDiscreteDistribution1D(AbsDiscreteDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsDiscreteDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ShiftableDiscreteDistribution1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsDiscreteDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ShiftableDiscreteDistribution1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_ShiftableDiscreteDistribution1D
	__del__ = lambda self: None

	def location(self) -> "long":
	return _npstat.ShiftableDiscreteDistribution1D_location(self)

	def setLocation(self, v: 'long const') -> "void":
	return _npstat.ShiftableDiscreteDistribution1D_setLocation(self, v)

	def probability(self, x: 'long const') -> "double":
	return _npstat.ShiftableDiscreteDistribution1D_probability(self, x)

	def cdf(self, x: 'double const') -> "double":
	return _npstat.ShiftableDiscreteDistribution1D_cdf(self, x)

	def exceedance(self, x: 'double const') -> "double":
	return _npstat.ShiftableDiscreteDistribution1D_exceedance(self, x)

	def quantile(self, x: 'double const') -> "long":
	return _npstat.ShiftableDiscreteDistribution1D_quantile(self, x)

	def clone(self) -> "npstat::ShiftableDiscreteDistribution1D *":
	return _npstat.ShiftableDiscreteDistribution1D_clone(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.ShiftableDiscreteDistribution1D_classId(self)
	ShiftableDiscreteDistribution1D_swigregister = _npstat.ShiftableDiscreteDistribution1D_swigregister
	ShiftableDiscreteDistribution1D_swigregister(ShiftableDiscreteDistribution1D)

	class AbsDiscreteDistribution1DDistance(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsDiscreteDistribution1DDistance, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, AbsDiscreteDistribution1DDistance, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsDiscreteDistribution1DDistance
	__del__ = lambda self: None

	def __call__(self, prob1: 'AbsDiscreteDistribution1D', prob2: 'AbsDiscreteDistribution1D', pooled: 'AbsDiscreteDistribution1D', first: 'long', oneAboveLast: 'long') -> "double":
	return _npstat.AbsDiscreteDistribution1DDistance___call__(self, prob1, prob2, pooled, first, oneAboveLast)
	AbsDiscreteDistribution1DDistance_swigregister = _npstat.AbsDiscreteDistribution1DDistance_swigregister
	AbsDiscreteDistribution1DDistance_swigregister(AbsDiscreteDistribution1DDistance)

	class ArchiveRecord_AbsDiscreteDistribution1D(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_AbsDiscreteDistribution1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_AbsDiscreteDistribution1D, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'AbsDiscreteDistribution1D', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_AbsDiscreteDistribution1D(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_AbsDiscreteDistribution1D
	__del__ = lambda self: None
	ArchiveRecord_AbsDiscreteDistribution1D_swigregister = _npstat.ArchiveRecord_AbsDiscreteDistribution1D_swigregister
	ArchiveRecord_AbsDiscreteDistribution1D_swigregister(ArchiveRecord_AbsDiscreteDistribution1D)

	class GridAxis(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, GridAxis, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, GridAxis, name)
	__repr__ = _swig_repr

	def coords(self) -> "std::vector< double,std::allocator< double > > const &":
	return _npstat.GridAxis_coords(self)

	def label(self) -> "std::string const &":
	return _npstat.GridAxis_label(self)

	def usesLogSpace(self) -> "bool":
	return _npstat.GridAxis_usesLogSpace(self)

	def getInterval(self, coordinate: 'double') -> "std::pair< unsigned int,double >":
	return _npstat.GridAxis_getInterval(self, coordinate)

	def linearInterval(self, coordinate: 'double') -> "std::pair< unsigned int,double >":
	return _npstat.GridAxis_linearInterval(self, coordinate)

	def nCoords(self) -> "unsigned int":
	return _npstat.GridAxis_nCoords(self)

	def coordinate(self, i: 'unsigned int const') -> "double":
	return _npstat.GridAxis_coordinate(self, i)

	def min(self) -> "double":
	return _npstat.GridAxis_min(self)

	def max(self) -> "double":
	return _npstat.GridAxis_max(self)

	def length(self) -> "double":
	return _npstat.GridAxis_length(self)

	def isUniform(self) -> "bool":
	return _npstat.GridAxis_isUniform(self)

	def nIntervals(self) -> "unsigned int":
	return _npstat.GridAxis_nIntervals(self)

	def intervalWidth(self, i: 'unsigned int const'=0) -> "double":
	return _npstat.GridAxis_intervalWidth(self, i)

	def __eq__(self, r: 'GridAxis') -> "bool":
	return _npstat.GridAxis___eq__(self, r)

	def __ne__(self, r: 'GridAxis') -> "bool":
	return _npstat.GridAxis___ne__(self, r)

	def isClose(self, r: 'GridAxis', tol: 'double') -> "bool":
	return _npstat.GridAxis_isClose(self, r, tol)

	def setLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.GridAxis_setLabel(self, newlabel)

	def classId(self) -> "gs::ClassId":
	return _npstat.GridAxis_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.GridAxis_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.GridAxis_classname)
	else:
	classname = _npstat.GridAxis_classname
	if _newclass:
	version = staticmethod(_npstat.GridAxis_version)
	else:
	version = _npstat.GridAxis_version
	if _newclass:
	read = staticmethod(_npstat.GridAxis_read)
	else:
	read = _npstat.GridAxis_read

	def range(self) -> "std::pair< double,double >":
	return _npstat.GridAxis_range(self)

	def __init__(self, *args):
	this = _npstat.new_GridAxis(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_GridAxis
	__del__ = lambda self: None
	GridAxis_swigregister = _npstat.GridAxis_swigregister
	GridAxis_swigregister(GridAxis)

	def GridAxis_classname() -> "char const *":
	return _npstat.GridAxis_classname()
	GridAxis_classname = _npstat.GridAxis_classname

	def GridAxis_version() -> "unsigned int":
	return _npstat.GridAxis_version()
	GridAxis_version = _npstat.GridAxis_version

	def GridAxis_read(id: 'ClassId', arg3: 'istream') -> "npstat::GridAxis *":
	return _npstat.GridAxis_read(id, arg3)
	GridAxis_read = _npstat.GridAxis_read

	class GridAxisVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, GridAxisVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, GridAxisVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.GridAxisVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.GridAxisVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.GridAxisVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::GridAxis >::size_type":
	return _npstat.GridAxisVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::GridAxis >::difference_type', j: 'std::vector< npstat::GridAxis >::difference_type') -> "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > *":
	return _npstat.GridAxisVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.GridAxisVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::GridAxis >::difference_type', j: 'std::vector< npstat::GridAxis >::difference_type') -> "void":
	return _npstat.GridAxisVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.GridAxisVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::GridAxis >::value_type const &":
	return _npstat.GridAxisVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.GridAxisVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::GridAxis >::value_type":
	return _npstat.GridAxisVector_pop(self)

	def append(self, x: 'GridAxis') -> "void":
	return _npstat.GridAxisVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.GridAxisVector_empty(self)

	def size(self) -> "std::vector< npstat::GridAxis >::size_type":
	return _npstat.GridAxisVector_size(self)

	def swap(self, v: 'GridAxisVector') -> "void":
	return _npstat.GridAxisVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::GridAxis >::iterator":
	return _npstat.GridAxisVector_begin(self)

	def end(self) -> "std::vector< npstat::GridAxis >::iterator":
	return _npstat.GridAxisVector_end(self)

	def rbegin(self) -> "std::vector< npstat::GridAxis >::reverse_iterator":
	return _npstat.GridAxisVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::GridAxis >::reverse_iterator":
	return _npstat.GridAxisVector_rend(self)

	def clear(self) -> "void":
	return _npstat.GridAxisVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::GridAxis >::allocator_type":
	return _npstat.GridAxisVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.GridAxisVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::GridAxis >::iterator":
	return _npstat.GridAxisVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_GridAxisVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'GridAxis') -> "void":
	return _npstat.GridAxisVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::GridAxis >::value_type const &":
	return _npstat.GridAxisVector_front(self)

	def back(self) -> "std::vector< npstat::GridAxis >::value_type const &":
	return _npstat.GridAxisVector_back(self)

	def assign(self, n: 'std::vector< npstat::GridAxis >::size_type', x: 'GridAxis') -> "void":
	return _npstat.GridAxisVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.GridAxisVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.GridAxisVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::GridAxis >::size_type') -> "void":
	return _npstat.GridAxisVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::GridAxis >::size_type":
	return _npstat.GridAxisVector_capacity(self)
	__swig_destroy__ = _npstat.delete_GridAxisVector
	__del__ = lambda self: None
	GridAxisVector_swigregister = _npstat.GridAxisVector_swigregister
	GridAxisVector_swigregister(GridAxisVector)

	class AbsMultivariateFunctor(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsMultivariateFunctor, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, AbsMultivariateFunctor, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsMultivariateFunctor
	__del__ = lambda self: None

	def __call__(self, point: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.AbsMultivariateFunctor___call__(self, point, dim)

	def minDim(self) -> "unsigned int":
	return _npstat.AbsMultivariateFunctor_minDim(self)

	def maxDim(self) -> "unsigned int":
	return _npstat.AbsMultivariateFunctor_maxDim(self)
	AbsMultivariateFunctor_swigregister = _npstat.AbsMultivariateFunctor_swigregister
	AbsMultivariateFunctor_swigregister(AbsMultivariateFunctor)

	class Uniform1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Uniform1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Uniform1D, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double const', scale: 'double const'):
	this = _npstat.new_Uniform1D(location, scale)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::Uniform1D *":
	return _npstat.Uniform1D_clone(self)
	__swig_destroy__ = _npstat.delete_Uniform1D
	__del__ = lambda self: None

	def classId(self) -> "gs::ClassId":
	return _npstat.Uniform1D_classId(self)
	if _newclass:
	classname = staticmethod(_npstat.Uniform1D_classname)
	else:
	classname = _npstat.Uniform1D_classname
	if _newclass:
	version = staticmethod(_npstat.Uniform1D_version)
	else:
	version = _npstat.Uniform1D_version
	if _newclass:
	read = staticmethod(_npstat.Uniform1D_read)
	else:
	read = _npstat.Uniform1D_read
	Uniform1D_swigregister = _npstat.Uniform1D_swigregister
	Uniform1D_swigregister(Uniform1D)

	def Uniform1D_classname() -> "char const *":
	return _npstat.Uniform1D_classname()
	Uniform1D_classname = _npstat.Uniform1D_classname

	def Uniform1D_version() -> "unsigned int":
	return _npstat.Uniform1D_version()
	Uniform1D_version = _npstat.Uniform1D_version

	def Uniform1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::Uniform1D *":
	return _npstat.Uniform1D_read(id, arg3)
	Uniform1D_read = _npstat.Uniform1D_read

	class IsoscelesTriangle1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, IsoscelesTriangle1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, IsoscelesTriangle1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr

	def clone(self) -> "npstat::IsoscelesTriangle1D *":
	return _npstat.IsoscelesTriangle1D_clone(self)
	__swig_destroy__ = _npstat.delete_IsoscelesTriangle1D
	__del__ = lambda self: None

	def classId(self) -> "gs::ClassId":
	return _npstat.IsoscelesTriangle1D_classId(self)
	if _newclass:
	classname = staticmethod(_npstat.IsoscelesTriangle1D_classname)
	else:
	classname = _npstat.IsoscelesTriangle1D_classname
	if _newclass:
	version = staticmethod(_npstat.IsoscelesTriangle1D_version)
	else:
	version = _npstat.IsoscelesTriangle1D_version
	if _newclass:
	read = staticmethod(_npstat.IsoscelesTriangle1D_read)
	else:
	read = _npstat.IsoscelesTriangle1D_read
	IsoscelesTriangle1D_swigregister = _npstat.IsoscelesTriangle1D_swigregister
	IsoscelesTriangle1D_swigregister(IsoscelesTriangle1D)

	def IsoscelesTriangle1D_classname() -> "char const *":
	return _npstat.IsoscelesTriangle1D_classname()
	IsoscelesTriangle1D_classname = _npstat.IsoscelesTriangle1D_classname

	def IsoscelesTriangle1D_version() -> "unsigned int":
	return _npstat.IsoscelesTriangle1D_version()
	IsoscelesTriangle1D_version = _npstat.IsoscelesTriangle1D_version

	def IsoscelesTriangle1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::IsoscelesTriangle1D *":
	return _npstat.IsoscelesTriangle1D_read(id, arg3)
	IsoscelesTriangle1D_read = _npstat.IsoscelesTriangle1D_read

	class Exponential1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Exponential1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Exponential1D, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double const', scale: 'double const'):
	this = _npstat.new_Exponential1D(location, scale)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::Exponential1D *":
	return _npstat.Exponential1D_clone(self)
	__swig_destroy__ = _npstat.delete_Exponential1D
	__del__ = lambda self: None

	def classId(self) -> "gs::ClassId":
	return _npstat.Exponential1D_classId(self)
	if _newclass:
	classname = staticmethod(_npstat.Exponential1D_classname)
	else:
	classname = _npstat.Exponential1D_classname
	if _newclass:
	version = staticmethod(_npstat.Exponential1D_version)
	else:
	version = _npstat.Exponential1D_version
	if _newclass:
	read = staticmethod(_npstat.Exponential1D_read)
	else:
	read = _npstat.Exponential1D_read
	Exponential1D_swigregister = _npstat.Exponential1D_swigregister
	Exponential1D_swigregister(Exponential1D)

	def Exponential1D_classname() -> "char const *":
	return _npstat.Exponential1D_classname()
	Exponential1D_classname = _npstat.Exponential1D_classname

	def Exponential1D_version() -> "unsigned int":
	return _npstat.Exponential1D_version()
	Exponential1D_version = _npstat.Exponential1D_version

	def Exponential1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::Exponential1D *":
	return _npstat.Exponential1D_read(id, arg3)
	Exponential1D_read = _npstat.Exponential1D_read

	class Logistic1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Logistic1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Logistic1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr

	def clone(self) -> "npstat::Logistic1D *":
	return _npstat.Logistic1D_clone(self)
	__swig_destroy__ = _npstat.delete_Logistic1D
	__del__ = lambda self: None

	def classId(self) -> "gs::ClassId":
	return _npstat.Logistic1D_classId(self)
	if _newclass:
	classname = staticmethod(_npstat.Logistic1D_classname)
	else:
	classname = _npstat.Logistic1D_classname
	if _newclass:
	version = staticmethod(_npstat.Logistic1D_version)
	else:
	version = _npstat.Logistic1D_version
	if _newclass:
	read = staticmethod(_npstat.Logistic1D_read)
	else:
	read = _npstat.Logistic1D_read
	Logistic1D_swigregister = _npstat.Logistic1D_swigregister
	Logistic1D_swigregister(Logistic1D)

	def Logistic1D_classname() -> "char const *":
	return _npstat.Logistic1D_classname()
	Logistic1D_classname = _npstat.Logistic1D_classname

	def Logistic1D_version() -> "unsigned int":
	return _npstat.Logistic1D_version()
	Logistic1D_version = _npstat.Logistic1D_version

	def Logistic1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::Logistic1D *":
	return _npstat.Logistic1D_read(id, arg3)
	Logistic1D_read = _npstat.Logistic1D_read

	class Quadratic1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Quadratic1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Quadratic1D, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double', scale: 'double', a: 'double', b: 'double'):
	this = _npstat.new_Quadratic1D(location, scale, a, b)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::Quadratic1D *":
	return _npstat.Quadratic1D_clone(self)
	__swig_destroy__ = _npstat.delete_Quadratic1D
	__del__ = lambda self: None

	def a(self) -> "double":
	return _npstat.Quadratic1D_a(self)

	def b(self) -> "double":
	return _npstat.Quadratic1D_b(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.Quadratic1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.Quadratic1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.Quadratic1D_classname)
	else:
	classname = _npstat.Quadratic1D_classname
	if _newclass:
	version = staticmethod(_npstat.Quadratic1D_version)
	else:
	version = _npstat.Quadratic1D_version
	if _newclass:
	read = staticmethod(_npstat.Quadratic1D_read)
	else:
	read = _npstat.Quadratic1D_read
	Quadratic1D_swigregister = _npstat.Quadratic1D_swigregister
	Quadratic1D_swigregister(Quadratic1D)

	def Quadratic1D_classname() -> "char const *":
	return _npstat.Quadratic1D_classname()
	Quadratic1D_classname = _npstat.Quadratic1D_classname

	def Quadratic1D_version() -> "unsigned int":
	return _npstat.Quadratic1D_version()
	Quadratic1D_version = _npstat.Quadratic1D_version

	def Quadratic1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::Quadratic1D *":
	return _npstat.Quadratic1D_read(id, arg3)
	Quadratic1D_read = _npstat.Quadratic1D_read

	class LogQuadratic1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LogQuadratic1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LogQuadratic1D, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double', scale: 'double', a: 'double', b: 'double'):
	this = _npstat.new_LogQuadratic1D(location, scale, a, b)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::LogQuadratic1D *":
	return _npstat.LogQuadratic1D_clone(self)
	__swig_destroy__ = _npstat.delete_LogQuadratic1D
	__del__ = lambda self: None

	def a(self) -> "double":
	return _npstat.LogQuadratic1D_a(self)

	def b(self) -> "double":
	return _npstat.LogQuadratic1D_b(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.LogQuadratic1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.LogQuadratic1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.LogQuadratic1D_classname)
	else:
	classname = _npstat.LogQuadratic1D_classname
	if _newclass:
	version = staticmethod(_npstat.LogQuadratic1D_version)
	else:
	version = _npstat.LogQuadratic1D_version
	if _newclass:
	read = staticmethod(_npstat.LogQuadratic1D_read)
	else:
	read = _npstat.LogQuadratic1D_read
	LogQuadratic1D_swigregister = _npstat.LogQuadratic1D_swigregister
	LogQuadratic1D_swigregister(LogQuadratic1D)

	def LogQuadratic1D_classname() -> "char const *":
	return _npstat.LogQuadratic1D_classname()
	LogQuadratic1D_classname = _npstat.LogQuadratic1D_classname

	def LogQuadratic1D_version() -> "unsigned int":
	return _npstat.LogQuadratic1D_version()
	LogQuadratic1D_version = _npstat.LogQuadratic1D_version

	def LogQuadratic1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::LogQuadratic1D *":
	return _npstat.LogQuadratic1D_read(id, arg3)
	LogQuadratic1D_read = _npstat.LogQuadratic1D_read

	class Gauss1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Gauss1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Gauss1D, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double const', scale: 'double const'):
	this = _npstat.new_Gauss1D(location, scale)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::Gauss1D *":
	return _npstat.Gauss1D_clone(self)
	__swig_destroy__ = _npstat.delete_Gauss1D
	__del__ = lambda self: None

	def classId(self) -> "gs::ClassId":
	return _npstat.Gauss1D_classId(self)
	if _newclass:
	classname = staticmethod(_npstat.Gauss1D_classname)
	else:
	classname = _npstat.Gauss1D_classname
	if _newclass:
	version = staticmethod(_npstat.Gauss1D_version)
	else:
	version = _npstat.Gauss1D_version
	if _newclass:
	read = staticmethod(_npstat.Gauss1D_read)
	else:
	read = _npstat.Gauss1D_read
	Gauss1D_swigregister = _npstat.Gauss1D_swigregister
	Gauss1D_swigregister(Gauss1D)

	def Gauss1D_classname() -> "char const *":
	return _npstat.Gauss1D_classname()
	Gauss1D_classname = _npstat.Gauss1D_classname

	def Gauss1D_version() -> "unsigned int":
	return _npstat.Gauss1D_version()
	Gauss1D_version = _npstat.Gauss1D_version

	def Gauss1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::Gauss1D *":
	return _npstat.Gauss1D_read(id, arg3)
	Gauss1D_read = _npstat.Gauss1D_read

	class TruncatedGauss1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, TruncatedGauss1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, TruncatedGauss1D, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double', scale: 'double', nsigma: 'double'):
	this = _npstat.new_TruncatedGauss1D(location, scale, nsigma)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::TruncatedGauss1D *":
	return _npstat.TruncatedGauss1D_clone(self)
	__swig_destroy__ = _npstat.delete_TruncatedGauss1D
	__del__ = lambda self: None

	def nsigma(self) -> "double":
	return _npstat.TruncatedGauss1D_nsigma(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.TruncatedGauss1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.TruncatedGauss1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.TruncatedGauss1D_classname)
	else:
	classname = _npstat.TruncatedGauss1D_classname
	if _newclass:
	version = staticmethod(_npstat.TruncatedGauss1D_version)
	else:
	version = _npstat.TruncatedGauss1D_version
	if _newclass:
	read = staticmethod(_npstat.TruncatedGauss1D_read)
	else:
	read = _npstat.TruncatedGauss1D_read
	TruncatedGauss1D_swigregister = _npstat.TruncatedGauss1D_swigregister
	TruncatedGauss1D_swigregister(TruncatedGauss1D)

	def TruncatedGauss1D_classname() -> "char const *":
	return _npstat.TruncatedGauss1D_classname()
	TruncatedGauss1D_classname = _npstat.TruncatedGauss1D_classname

	def TruncatedGauss1D_version() -> "unsigned int":
	return _npstat.TruncatedGauss1D_version()
	TruncatedGauss1D_version = _npstat.TruncatedGauss1D_version

	def TruncatedGauss1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::TruncatedGauss1D *":
	return _npstat.TruncatedGauss1D_read(id, arg3)
	TruncatedGauss1D_read = _npstat.TruncatedGauss1D_read

	class MirroredGauss1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, MirroredGauss1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, MirroredGauss1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr

	def clone(self) -> "npstat::MirroredGauss1D *":
	return _npstat.MirroredGauss1D_clone(self)
	__swig_destroy__ = _npstat.delete_MirroredGauss1D
	__del__ = lambda self: None

	def meanOn0_1(self) -> "double":
	return _npstat.MirroredGauss1D_meanOn0_1(self)

	def sigmaOn0_1(self) -> "double":
	return _npstat.MirroredGauss1D_sigmaOn0_1(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.MirroredGauss1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.MirroredGauss1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.MirroredGauss1D_classname)
	else:
	classname = _npstat.MirroredGauss1D_classname
	if _newclass:
	version = staticmethod(_npstat.MirroredGauss1D_version)
	else:
	version = _npstat.MirroredGauss1D_version
	if _newclass:
	read = staticmethod(_npstat.MirroredGauss1D_read)
	else:
	read = _npstat.MirroredGauss1D_read
	MirroredGauss1D_swigregister = _npstat.MirroredGauss1D_swigregister
	MirroredGauss1D_swigregister(MirroredGauss1D)

	def MirroredGauss1D_classname() -> "char const *":
	return _npstat.MirroredGauss1D_classname()
	MirroredGauss1D_classname = _npstat.MirroredGauss1D_classname

	def MirroredGauss1D_version() -> "unsigned int":
	return _npstat.MirroredGauss1D_version()
	MirroredGauss1D_version = _npstat.MirroredGauss1D_version

	def MirroredGauss1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::MirroredGauss1D *":
	return _npstat.MirroredGauss1D_read(id, arg3)
	MirroredGauss1D_read = _npstat.MirroredGauss1D_read

	class BifurcatedGauss1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, BifurcatedGauss1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, BifurcatedGauss1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr

	def clone(self) -> "npstat::BifurcatedGauss1D *":
	return _npstat.BifurcatedGauss1D_clone(self)
	__swig_destroy__ = _npstat.delete_BifurcatedGauss1D
	__del__ = lambda self: None

	def leftSigmaFraction(self) -> "double":
	return _npstat.BifurcatedGauss1D_leftSigmaFraction(self)

	def nSigmasLeft(self) -> "double":
	return _npstat.BifurcatedGauss1D_nSigmasLeft(self)

	def nSigmasRight(self) -> "double":
	return _npstat.BifurcatedGauss1D_nSigmasRight(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.BifurcatedGauss1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.BifurcatedGauss1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.BifurcatedGauss1D_classname)
	else:
	classname = _npstat.BifurcatedGauss1D_classname
	if _newclass:
	version = staticmethod(_npstat.BifurcatedGauss1D_version)
	else:
	version = _npstat.BifurcatedGauss1D_version
	if _newclass:
	read = staticmethod(_npstat.BifurcatedGauss1D_read)
	else:
	read = _npstat.BifurcatedGauss1D_read
	BifurcatedGauss1D_swigregister = _npstat.BifurcatedGauss1D_swigregister
	BifurcatedGauss1D_swigregister(BifurcatedGauss1D)

	def BifurcatedGauss1D_classname() -> "char const *":
	return _npstat.BifurcatedGauss1D_classname()
	BifurcatedGauss1D_classname = _npstat.BifurcatedGauss1D_classname

	def BifurcatedGauss1D_version() -> "unsigned int":
	return _npstat.BifurcatedGauss1D_version()
	BifurcatedGauss1D_version = _npstat.BifurcatedGauss1D_version

	def BifurcatedGauss1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::BifurcatedGauss1D *":
	return _npstat.BifurcatedGauss1D_read(id, arg3)
	BifurcatedGauss1D_read = _npstat.BifurcatedGauss1D_read

	class SymmetricBeta1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, SymmetricBeta1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, SymmetricBeta1D, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double', scale: 'double', power: 'double'):
	this = _npstat.new_SymmetricBeta1D(location, scale, power)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::SymmetricBeta1D *":
	return _npstat.SymmetricBeta1D_clone(self)
	__swig_destroy__ = _npstat.delete_SymmetricBeta1D
	__del__ = lambda self: None

	def power(self) -> "double":
	return _npstat.SymmetricBeta1D_power(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.SymmetricBeta1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.SymmetricBeta1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.SymmetricBeta1D_classname)
	else:
	classname = _npstat.SymmetricBeta1D_classname
	if _newclass:
	version = staticmethod(_npstat.SymmetricBeta1D_version)
	else:
	version = _npstat.SymmetricBeta1D_version
	if _newclass:
	read = staticmethod(_npstat.SymmetricBeta1D_read)
	else:
	read = _npstat.SymmetricBeta1D_read
	SymmetricBeta1D_swigregister = _npstat.SymmetricBeta1D_swigregister
	SymmetricBeta1D_swigregister(SymmetricBeta1D)

	def SymmetricBeta1D_classname() -> "char const *":
	return _npstat.SymmetricBeta1D_classname()
	SymmetricBeta1D_classname = _npstat.SymmetricBeta1D_classname

	def SymmetricBeta1D_version() -> "unsigned int":
	return _npstat.SymmetricBeta1D_version()
	SymmetricBeta1D_version = _npstat.SymmetricBeta1D_version

	def SymmetricBeta1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::SymmetricBeta1D *":
	return _npstat.SymmetricBeta1D_read(id, arg3)
	SymmetricBeta1D_read = _npstat.SymmetricBeta1D_read

	class Beta1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Beta1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Beta1D, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double', scale: 'double', alpha: 'double', beta: 'double'):
	this = _npstat.new_Beta1D(location, scale, alpha, beta)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::Beta1D *":
	return _npstat.Beta1D_clone(self)
	__swig_destroy__ = _npstat.delete_Beta1D
	__del__ = lambda self: None

	def alpha(self) -> "double":
	return _npstat.Beta1D_alpha(self)

	def beta(self) -> "double":
	return _npstat.Beta1D_beta(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.Beta1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.Beta1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.Beta1D_classname)
	else:
	classname = _npstat.Beta1D_classname
	if _newclass:
	version = staticmethod(_npstat.Beta1D_version)
	else:
	version = _npstat.Beta1D_version
	if _newclass:
	read = staticmethod(_npstat.Beta1D_read)
	else:
	read = _npstat.Beta1D_read
	Beta1D_swigregister = _npstat.Beta1D_swigregister
	Beta1D_swigregister(Beta1D)

	def Beta1D_classname() -> "char const *":
	return _npstat.Beta1D_classname()
	Beta1D_classname = _npstat.Beta1D_classname

	def Beta1D_version() -> "unsigned int":
	return _npstat.Beta1D_version()
	Beta1D_version = _npstat.Beta1D_version

	def Beta1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::Beta1D *":
	return _npstat.Beta1D_read(id, arg3)
	Beta1D_read = _npstat.Beta1D_read

	class Gamma1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Gamma1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Gamma1D, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double', scale: 'double', alpha: 'double'):
	this = _npstat.new_Gamma1D(location, scale, alpha)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::Gamma1D *":
	return _npstat.Gamma1D_clone(self)
	__swig_destroy__ = _npstat.delete_Gamma1D
	__del__ = lambda self: None

	def alpha(self) -> "double":
	return _npstat.Gamma1D_alpha(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.Gamma1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.Gamma1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.Gamma1D_classname)
	else:
	classname = _npstat.Gamma1D_classname
	if _newclass:
	version = staticmethod(_npstat.Gamma1D_version)
	else:
	version = _npstat.Gamma1D_version
	if _newclass:
	read = staticmethod(_npstat.Gamma1D_read)
	else:
	read = _npstat.Gamma1D_read
	Gamma1D_swigregister = _npstat.Gamma1D_swigregister
	Gamma1D_swigregister(Gamma1D)

	def Gamma1D_classname() -> "char const *":
	return _npstat.Gamma1D_classname()
	Gamma1D_classname = _npstat.Gamma1D_classname

	def Gamma1D_version() -> "unsigned int":
	return _npstat.Gamma1D_version()
	Gamma1D_version = _npstat.Gamma1D_version

	def Gamma1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::Gamma1D *":
	return _npstat.Gamma1D_read(id, arg3)
	Gamma1D_read = _npstat.Gamma1D_read

	class Pareto1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Pareto1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Pareto1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr

	def clone(self) -> "npstat::Pareto1D *":
	return _npstat.Pareto1D_clone(self)
	__swig_destroy__ = _npstat.delete_Pareto1D
	__del__ = lambda self: None

	def powerParameter(self) -> "double":
	return _npstat.Pareto1D_powerParameter(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.Pareto1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.Pareto1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.Pareto1D_classname)
	else:
	classname = _npstat.Pareto1D_classname
	if _newclass:
	version = staticmethod(_npstat.Pareto1D_version)
	else:
	version = _npstat.Pareto1D_version
	if _newclass:
	read = staticmethod(_npstat.Pareto1D_read)
	else:
	read = _npstat.Pareto1D_read
	Pareto1D_swigregister = _npstat.Pareto1D_swigregister
	Pareto1D_swigregister(Pareto1D)

	def Pareto1D_classname() -> "char const *":
	return _npstat.Pareto1D_classname()
	Pareto1D_classname = _npstat.Pareto1D_classname

	def Pareto1D_version() -> "unsigned int":
	return _npstat.Pareto1D_version()
	Pareto1D_version = _npstat.Pareto1D_version

	def Pareto1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::Pareto1D *":
	return _npstat.Pareto1D_read(id, arg3)
	Pareto1D_read = _npstat.Pareto1D_read

	class UniPareto1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UniPareto1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UniPareto1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr

	def clone(self) -> "npstat::UniPareto1D *":
	return _npstat.UniPareto1D_clone(self)
	__swig_destroy__ = _npstat.delete_UniPareto1D
	__del__ = lambda self: None

	def powerParameter(self) -> "double":
	return _npstat.UniPareto1D_powerParameter(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.UniPareto1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.UniPareto1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.UniPareto1D_classname)
	else:
	classname = _npstat.UniPareto1D_classname
	if _newclass:
	version = staticmethod(_npstat.UniPareto1D_version)
	else:
	version = _npstat.UniPareto1D_version
	if _newclass:
	read = staticmethod(_npstat.UniPareto1D_read)
	else:
	read = _npstat.UniPareto1D_read
	UniPareto1D_swigregister = _npstat.UniPareto1D_swigregister
	UniPareto1D_swigregister(UniPareto1D)

	def UniPareto1D_classname() -> "char const *":
	return _npstat.UniPareto1D_classname()
	UniPareto1D_classname = _npstat.UniPareto1D_classname

	def UniPareto1D_version() -> "unsigned int":
	return _npstat.UniPareto1D_version()
	UniPareto1D_version = _npstat.UniPareto1D_version

	def UniPareto1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::UniPareto1D *":
	return _npstat.UniPareto1D_read(id, arg3)
	UniPareto1D_read = _npstat.UniPareto1D_read

	class Huber1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Huber1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Huber1D, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double', scale: 'double', tailWeight: 'double'):
	this = _npstat.new_Huber1D(location, scale, tailWeight)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::Huber1D *":
	return _npstat.Huber1D_clone(self)
	__swig_destroy__ = _npstat.delete_Huber1D
	__del__ = lambda self: None

	def tailWeight(self) -> "double":
	return _npstat.Huber1D_tailWeight(self)

	def tailStart(self) -> "double":
	return _npstat.Huber1D_tailStart(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.Huber1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.Huber1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.Huber1D_classname)
	else:
	classname = _npstat.Huber1D_classname
	if _newclass:
	version = staticmethod(_npstat.Huber1D_version)
	else:
	version = _npstat.Huber1D_version
	if _newclass:
	read = staticmethod(_npstat.Huber1D_read)
	else:
	read = _npstat.Huber1D_read
	Huber1D_swigregister = _npstat.Huber1D_swigregister
	Huber1D_swigregister(Huber1D)

	def Huber1D_classname() -> "char const *":
	return _npstat.Huber1D_classname()
	Huber1D_classname = _npstat.Huber1D_classname

	def Huber1D_version() -> "unsigned int":
	return _npstat.Huber1D_version()
	Huber1D_version = _npstat.Huber1D_version

	def Huber1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::Huber1D *":
	return _npstat.Huber1D_read(id, arg3)
	Huber1D_read = _npstat.Huber1D_read

	class Cauchy1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Cauchy1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Cauchy1D, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double', scale: 'double'):
	this = _npstat.new_Cauchy1D(location, scale)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::Cauchy1D *":
	return _npstat.Cauchy1D_clone(self)
	__swig_destroy__ = _npstat.delete_Cauchy1D
	__del__ = lambda self: None

	def classId(self) -> "gs::ClassId":
	return _npstat.Cauchy1D_classId(self)
	if _newclass:
	classname = staticmethod(_npstat.Cauchy1D_classname)
	else:
	classname = _npstat.Cauchy1D_classname
	if _newclass:
	version = staticmethod(_npstat.Cauchy1D_version)
	else:
	version = _npstat.Cauchy1D_version
	if _newclass:
	read = staticmethod(_npstat.Cauchy1D_read)
	else:
	read = _npstat.Cauchy1D_read
	Cauchy1D_swigregister = _npstat.Cauchy1D_swigregister
	Cauchy1D_swigregister(Cauchy1D)

	def Cauchy1D_classname() -> "char const *":
	return _npstat.Cauchy1D_classname()
	Cauchy1D_classname = _npstat.Cauchy1D_classname

	def Cauchy1D_version() -> "unsigned int":
	return _npstat.Cauchy1D_version()
	Cauchy1D_version = _npstat.Cauchy1D_version

	def Cauchy1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::Cauchy1D *":
	return _npstat.Cauchy1D_read(id, arg3)
	Cauchy1D_read = _npstat.Cauchy1D_read

	class LogNormal(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LogNormal, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LogNormal, name)
	__repr__ = _swig_repr

	def __init__(self, mean: 'double', stdev: 'double', skewness: 'double'):
	this = _npstat.new_LogNormal(mean, stdev, skewness)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::LogNormal *":
	return _npstat.LogNormal_clone(self)
	__swig_destroy__ = _npstat.delete_LogNormal
	__del__ = lambda self: None

	def skewness(self) -> "double":
	return _npstat.LogNormal_skewness(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.LogNormal_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.LogNormal_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.LogNormal_classname)
	else:
	classname = _npstat.LogNormal_classname
	if _newclass:
	version = staticmethod(_npstat.LogNormal_version)
	else:
	version = _npstat.LogNormal_version
	if _newclass:
	read = staticmethod(_npstat.LogNormal_read)
	else:
	read = _npstat.LogNormal_read
	LogNormal_swigregister = _npstat.LogNormal_swigregister
	LogNormal_swigregister(LogNormal)

	def LogNormal_classname() -> "char const *":
	return _npstat.LogNormal_classname()
	LogNormal_classname = _npstat.LogNormal_classname

	def LogNormal_version() -> "unsigned int":
	return _npstat.LogNormal_version()
	LogNormal_version = _npstat.LogNormal_version

	def LogNormal_read(id: 'ClassId', arg3: 'istream') -> "npstat::LogNormal *":
	return _npstat.LogNormal_read(id, arg3)
	LogNormal_read = _npstat.LogNormal_read

	class Moyal1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Moyal1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Moyal1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr

	def clone(self) -> "npstat::Moyal1D *":
	return _npstat.Moyal1D_clone(self)
	__swig_destroy__ = _npstat.delete_Moyal1D
	__del__ = lambda self: None

	def classId(self) -> "gs::ClassId":
	return _npstat.Moyal1D_classId(self)
	if _newclass:
	classname = staticmethod(_npstat.Moyal1D_classname)
	else:
	classname = _npstat.Moyal1D_classname
	if _newclass:
	version = staticmethod(_npstat.Moyal1D_version)
	else:
	version = _npstat.Moyal1D_version
	if _newclass:
	read = staticmethod(_npstat.Moyal1D_read)
	else:
	read = _npstat.Moyal1D_read
	Moyal1D_swigregister = _npstat.Moyal1D_swigregister
	Moyal1D_swigregister(Moyal1D)

	def Moyal1D_classname() -> "char const *":
	return _npstat.Moyal1D_classname()
	Moyal1D_classname = _npstat.Moyal1D_classname

	def Moyal1D_version() -> "unsigned int":
	return _npstat.Moyal1D_version()
	Moyal1D_version = _npstat.Moyal1D_version

	def Moyal1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::Moyal1D *":
	return _npstat.Moyal1D_read(id, arg3)
	Moyal1D_read = _npstat.Moyal1D_read

	class StudentsT1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, StudentsT1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, StudentsT1D, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double', scale: 'double', nDegreesOfFreedom: 'double'):
	this = _npstat.new_StudentsT1D(location, scale, nDegreesOfFreedom)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::StudentsT1D *":
	return _npstat.StudentsT1D_clone(self)
	__swig_destroy__ = _npstat.delete_StudentsT1D
	__del__ = lambda self: None

	def nDegreesOfFreedom(self) -> "double":
	return _npstat.StudentsT1D_nDegreesOfFreedom(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.StudentsT1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.StudentsT1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.StudentsT1D_classname)
	else:
	classname = _npstat.StudentsT1D_classname
	if _newclass:
	version = staticmethod(_npstat.StudentsT1D_version)
	else:
	version = _npstat.StudentsT1D_version
	if _newclass:
	read = staticmethod(_npstat.StudentsT1D_read)
	else:
	read = _npstat.StudentsT1D_read
	StudentsT1D_swigregister = _npstat.StudentsT1D_swigregister
	StudentsT1D_swigregister(StudentsT1D)

	def StudentsT1D_classname() -> "char const *":
	return _npstat.StudentsT1D_classname()
	StudentsT1D_classname = _npstat.StudentsT1D_classname

	def StudentsT1D_version() -> "unsigned int":
	return _npstat.StudentsT1D_version()
	StudentsT1D_version = _npstat.StudentsT1D_version

	def StudentsT1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::StudentsT1D *":
	return _npstat.StudentsT1D_read(id, arg3)
	StudentsT1D_read = _npstat.StudentsT1D_read

	class Tabulated1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Tabulated1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Tabulated1D, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double const', scale: 'double const', table: 'DoubleVector', interpolationDegree: 'unsigned int const'):
	this = _npstat.new_Tabulated1D(location, scale, table, interpolationDegree)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::Tabulated1D *":
	return _npstat.Tabulated1D_clone(self)
	__swig_destroy__ = _npstat.delete_Tabulated1D
	__del__ = lambda self: None

	def interpolationDegree(self) -> "unsigned int":
	return _npstat.Tabulated1D_interpolationDegree(self)

	def tableLength(self) -> "unsigned int":
	return _npstat.Tabulated1D_tableLength(self)

	def tableData(self) -> "double const *":
	return _npstat.Tabulated1D_tableData(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.Tabulated1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.Tabulated1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.Tabulated1D_classname)
	else:
	classname = _npstat.Tabulated1D_classname
	if _newclass:
	version = staticmethod(_npstat.Tabulated1D_version)
	else:
	version = _npstat.Tabulated1D_version
	if _newclass:
	read = staticmethod(_npstat.Tabulated1D_read)
	else:
	read = _npstat.Tabulated1D_read
	Tabulated1D_swigregister = _npstat.Tabulated1D_swigregister
	Tabulated1D_swigregister(Tabulated1D)

	def Tabulated1D_classname() -> "char const *":
	return _npstat.Tabulated1D_classname()
	Tabulated1D_classname = _npstat.Tabulated1D_classname

	def Tabulated1D_version() -> "unsigned int":
	return _npstat.Tabulated1D_version()
	Tabulated1D_version = _npstat.Tabulated1D_version

	def Tabulated1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::Tabulated1D *":
	return _npstat.Tabulated1D_read(id, arg3)
	Tabulated1D_read = _npstat.Tabulated1D_read

	class BinnedDensity1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, BinnedDensity1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, BinnedDensity1D, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double const', scale: 'double const', table: 'DoubleVector', interpolationDegree: 'unsigned int const'):
	this = _npstat.new_BinnedDensity1D(location, scale, table, interpolationDegree)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::BinnedDensity1D *":
	return _npstat.BinnedDensity1D_clone(self)
	__swig_destroy__ = _npstat.delete_BinnedDensity1D
	__del__ = lambda self: None

	def interpolationDegree(self) -> "unsigned int":
	return _npstat.BinnedDensity1D_interpolationDegree(self)

	def tableLength(self) -> "unsigned int":
	return _npstat.BinnedDensity1D_tableLength(self)

	def tableData(self) -> "double const *":
	return _npstat.BinnedDensity1D_tableData(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.BinnedDensity1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.BinnedDensity1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.BinnedDensity1D_classname)
	else:
	classname = _npstat.BinnedDensity1D_classname
	if _newclass:
	version = staticmethod(_npstat.BinnedDensity1D_version)
	else:
	version = _npstat.BinnedDensity1D_version
	if _newclass:
	read = staticmethod(_npstat.BinnedDensity1D_read)
	else:
	read = _npstat.BinnedDensity1D_read
	BinnedDensity1D_swigregister = _npstat.BinnedDensity1D_swigregister
	BinnedDensity1D_swigregister(BinnedDensity1D)

	def BinnedDensity1D_classname() -> "char const *":
	return _npstat.BinnedDensity1D_classname()
	BinnedDensity1D_classname = _npstat.BinnedDensity1D_classname

	def BinnedDensity1D_version() -> "unsigned int":
	return _npstat.BinnedDensity1D_version()
	BinnedDensity1D_version = _npstat.BinnedDensity1D_version

	def BinnedDensity1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::BinnedDensity1D *":
	return _npstat.BinnedDensity1D_read(id, arg3)
	BinnedDensity1D_read = _npstat.BinnedDensity1D_read

	class ArchiveRecord_Tabulated1D(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_Tabulated1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_Tabulated1D, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'Tabulated1D', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_Tabulated1D(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_Tabulated1D
	__del__ = lambda self: None
	ArchiveRecord_Tabulated1D_swigregister = _npstat.ArchiveRecord_Tabulated1D_swigregister
	ArchiveRecord_Tabulated1D_swigregister(ArchiveRecord_Tabulated1D)

	class Ref_Tabulated1D(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_Tabulated1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_Tabulated1D, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_Tabulated1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'Tabulated1D') -> "void":
	return _npstat.Ref_Tabulated1D_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::Tabulated1D *":
	return _npstat.Ref_Tabulated1D_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::Tabulated1D":
	return _npstat.Ref_Tabulated1D_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_Tabulated1D
	__del__ = lambda self: None
	Ref_Tabulated1D_swigregister = _npstat.Ref_Tabulated1D_swigregister
	Ref_Tabulated1D_swigregister(Ref_Tabulated1D)

	class ArchiveRecord_BinnedDensity1D(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_BinnedDensity1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_BinnedDensity1D, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'BinnedDensity1D', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_BinnedDensity1D(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_BinnedDensity1D
	__del__ = lambda self: None
	ArchiveRecord_BinnedDensity1D_swigregister = _npstat.ArchiveRecord_BinnedDensity1D_swigregister
	ArchiveRecord_BinnedDensity1D_swigregister(ArchiveRecord_BinnedDensity1D)

	class Ref_BinnedDensity1D(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_BinnedDensity1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_BinnedDensity1D, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_BinnedDensity1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'BinnedDensity1D') -> "void":
	return _npstat.Ref_BinnedDensity1D_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::BinnedDensity1D *":
	return _npstat.Ref_BinnedDensity1D_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::BinnedDensity1D":
	return _npstat.Ref_BinnedDensity1D_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_BinnedDensity1D
	__del__ = lambda self: None
	Ref_BinnedDensity1D_swigregister = _npstat.Ref_BinnedDensity1D_swigregister
	Ref_BinnedDensity1D_swigregister(Ref_BinnedDensity1D)

	class AbsDistributionND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsDistributionND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, AbsDistributionND, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsDistributionND
	__del__ = lambda self: None

	def clone(self) -> "npstat::AbsDistributionND *":
	return _npstat.AbsDistributionND_clone(self)

	def __eq__(self, r: 'AbsDistributionND') -> "bool":
	return _npstat.AbsDistributionND___eq__(self, r)

	def __ne__(self, r: 'AbsDistributionND') -> "bool":
	return _npstat.AbsDistributionND___ne__(self, r)

	def dim(self) -> "unsigned int":
	return _npstat.AbsDistributionND_dim(self)

	def density(self, x: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.AbsDistributionND_density(self, x, dim)

	def unitMap(self, rnd: 'double const ', bufLen: 'unsigned int', x: 'double ') -> "void":
	return _npstat.AbsDistributionND_unitMap(self, rnd, bufLen, x)

	def mappedByQuantiles(self) -> "bool":
	return _npstat.AbsDistributionND_mappedByQuantiles(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.AbsDistributionND_classId(self)

	def write(self, arg2: 'ostream') -> "bool":
	return _npstat.AbsDistributionND_write(self, arg2)
	if _newclass:
	classname = staticmethod(_npstat.AbsDistributionND_classname)
	else:
	classname = _npstat.AbsDistributionND_classname
	if _newclass:
	version = staticmethod(_npstat.AbsDistributionND_version)
	else:
	version = _npstat.AbsDistributionND_version
	if _newclass:
	read = staticmethod(_npstat.AbsDistributionND_read)
	else:
	read = _npstat.AbsDistributionND_read

	def random(self, g: 'AbsRandomGenerator') -> "std::vector< double,std::allocator< double > >":
	return _npstat.AbsDistributionND_random(self, g)

	def generate(self, g: 'AbsRandomGenerator', npoints: 'unsigned int') -> "std::vector< double,std::allocator< double > >":
	return _npstat.AbsDistributionND_generate(self, g, npoints)
	AbsDistributionND_swigregister = _npstat.AbsDistributionND_swigregister
	AbsDistributionND_swigregister(AbsDistributionND)

	def AbsDistributionND_classname() -> "char const *":
	return _npstat.AbsDistributionND_classname()
	AbsDistributionND_classname = _npstat.AbsDistributionND_classname

	def AbsDistributionND_version() -> "unsigned int":
	return _npstat.AbsDistributionND_version()
	AbsDistributionND_version = _npstat.AbsDistributionND_version

	def AbsDistributionND_read(id: 'ClassId', arg3: 'istream') -> "npstat::AbsDistributionND *":
	return _npstat.AbsDistributionND_read(id, arg3)
	AbsDistributionND_read = _npstat.AbsDistributionND_read

	class AbsScalableDistributionND(AbsDistributionND):
	__swig_setmethods__ = {}
	for _s in [AbsDistributionND]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsScalableDistributionND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsDistributionND]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, AbsScalableDistributionND, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsScalableDistributionND
	__del__ = lambda self: None

	def location(self, i: 'unsigned int') -> "double":
	return _npstat.AbsScalableDistributionND_location(self, i)

	def scale(self, i: 'unsigned int') -> "double":
	return _npstat.AbsScalableDistributionND_scale(self, i)

	def setLocation(self, i: 'unsigned int', v: 'double') -> "void":
	return _npstat.AbsScalableDistributionND_setLocation(self, i, v)

	def setScale(self, i: 'unsigned int', v: 'double') -> "void":
	return _npstat.AbsScalableDistributionND_setScale(self, i, v)

	def density(self, x: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.AbsScalableDistributionND_density(self, x, dim)

	def unitMap(self, rnd: 'double const ', dim: 'unsigned int', x: 'double ') -> "void":
	return _npstat.AbsScalableDistributionND_unitMap(self, rnd, dim, x)

	def clone(self) -> "npstat::AbsScalableDistributionND *":
	return _npstat.AbsScalableDistributionND_clone(self)

	def mappedByQuantiles(self) -> "bool":
	return _npstat.AbsScalableDistributionND_mappedByQuantiles(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.AbsScalableDistributionND_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.AbsScalableDistributionND_write(self, os)
	if _newclass:
	read = staticmethod(_npstat.AbsScalableDistributionND_read)
	else:
	read = _npstat.AbsScalableDistributionND_read
	AbsScalableDistributionND_swigregister = _npstat.AbsScalableDistributionND_swigregister
	AbsScalableDistributionND_swigregister(AbsScalableDistributionND)

	def AbsScalableDistributionND_read(arg2: 'istream', dim: 'unsigned int *', locations: 'DoubleVector', scales: 'DoubleVector') -> "bool":
	return _npstat.AbsScalableDistributionND_read(arg2, dim, locations, scales)
	AbsScalableDistributionND_read = _npstat.AbsScalableDistributionND_read

	class DensityFunctorND(AbsMultivariateFunctor):
	__swig_setmethods__ = {}
	for _s in [AbsMultivariateFunctor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DensityFunctorND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsMultivariateFunctor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DensityFunctorND, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistributionND'):
	this = _npstat.new_DensityFunctorND(fcn)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DensityFunctorND
	__del__ = lambda self: None

	def __call__(self, pt: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.DensityFunctorND___call__(self, pt, dim)

	def minDim(self) -> "unsigned int":
	return _npstat.DensityFunctorND_minDim(self)
	DensityFunctorND_swigregister = _npstat.DensityFunctorND_swigregister
	DensityFunctorND_swigregister(DensityFunctorND)

	class HomogeneousProductSymmetricBeta1D(AbsDistributionND):
	__swig_setmethods__ = {}
	for _s in [AbsDistributionND]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, HomogeneousProductSymmetricBeta1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsDistributionND]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, HomogeneousProductSymmetricBeta1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_HomogeneousProductSymmetricBeta1D
	__del__ = lambda self: None

	def clone(self) -> "npstat::HomogeneousProductDistroND< npstat::SymmetricBeta1D > *":
	return _npstat.HomogeneousProductSymmetricBeta1D_clone(self)

	def mappedByQuantiles(self) -> "bool":
	return _npstat.HomogeneousProductSymmetricBeta1D_mappedByQuantiles(self)

	def density(self, x: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.HomogeneousProductSymmetricBeta1D_density(self, x, dim)

	def unitMap(self, rnd: 'double const ', bufLen: 'unsigned int', x: 'double ') -> "void":
	return _npstat.HomogeneousProductSymmetricBeta1D_unitMap(self, rnd, bufLen, x)
	HomogeneousProductSymmetricBeta1D_swigregister = _npstat.HomogeneousProductSymmetricBeta1D_swigregister
	HomogeneousProductSymmetricBeta1D_swigregister(HomogeneousProductSymmetricBeta1D)

	class ArchiveRecord_AbsDistributionND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_AbsDistributionND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_AbsDistributionND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'AbsDistributionND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_AbsDistributionND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_AbsDistributionND
	__del__ = lambda self: None
	ArchiveRecord_AbsDistributionND_swigregister = _npstat.ArchiveRecord_AbsDistributionND_swigregister
	ArchiveRecord_AbsDistributionND_swigregister(ArchiveRecord_AbsDistributionND)

	class AbsGridInterpolatedDistribution(AbsDistributionND):
	__swig_setmethods__ = {}
	for _s in [AbsDistributionND]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsGridInterpolatedDistribution, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsDistributionND]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, AbsGridInterpolatedDistribution, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsGridInterpolatedDistribution
	__del__ = lambda self: None

	def clone(self) -> "npstat::AbsGridInterpolatedDistribution *":
	return _npstat.AbsGridInterpolatedDistribution_clone(self)

	def setGridDistro(self, cell: 'unsigned int const *', lenCell: 'unsigned int', distro: 'AbsDistributionND') -> "void":
	return _npstat.AbsGridInterpolatedDistribution_setGridDistro(self, cell, lenCell, distro)

	def setLinearDistro(self, idx: 'unsigned long', pd: 'AbsDistributionND') -> "void":
	return _npstat.AbsGridInterpolatedDistribution_setLinearDistro(self, idx, pd)

	def getGridDistro(self, cell: 'unsigned int const ', lenCell: 'unsigned int') -> "npstat::AbsDistributionND const ":
	return _npstat.AbsGridInterpolatedDistribution_getGridDistro(self, cell, lenCell)

	def getLinearDistro(self, idx: 'unsigned long') -> "npstat::AbsDistributionND const *":
	return _npstat.AbsGridInterpolatedDistribution_getLinearDistro(self, idx)

	def setGridCoords(self, coords: 'double const *', nCoords: 'unsigned int') -> "void":
	return _npstat.AbsGridInterpolatedDistribution_setGridCoords(self, coords, nCoords)

	def nAxes(self) -> "unsigned int":
	return _npstat.AbsGridInterpolatedDistribution_nAxes(self)

	def nDistros(self) -> "unsigned long":
	return _npstat.AbsGridInterpolatedDistribution_nDistros(self)

	def gridShape(self) -> "std::vector< unsigned int,std::allocator< unsigned int > >":
	return _npstat.AbsGridInterpolatedDistribution_gridShape(self)

	def getAxis(self, i: 'unsigned int') -> "npstat::GridAxis const &":
	return _npstat.AbsGridInterpolatedDistribution_getAxis(self, i)
	AbsGridInterpolatedDistribution_swigregister = _npstat.AbsGridInterpolatedDistribution_swigregister
	AbsGridInterpolatedDistribution_swigregister(AbsGridInterpolatedDistribution)

	class GridRandomizer(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, GridRandomizer, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, GridRandomizer, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_GridRandomizer
	__del__ = lambda self: None

	def __eq__(self, r: 'GridRandomizer') -> "bool":
	return _npstat.GridRandomizer___eq__(self, r)

	def __ne__(self, r: 'GridRandomizer') -> "bool":
	return _npstat.GridRandomizer___ne__(self, r)

	def gridData(self) -> "npstat::ArrayND< double > const &":
	return _npstat.GridRandomizer_gridData(self)

	def gridBoundary(self) -> "npstat::BoxND< double > const &":
	return _npstat.GridRandomizer_gridBoundary(self)

	def interpolationDegree(self) -> "unsigned int":
	return _npstat.GridRandomizer_interpolationDegree(self)

	def dim(self) -> "unsigned int":
	return _npstat.GridRandomizer_dim(self)

	def density(self, x: 'double const *', xLen: 'unsigned int') -> "double":
	return _npstat.GridRandomizer_density(self, x, xLen)

	def generate(self, uniformRandomInput: 'double const ', bufLen: 'unsigned int', resultBuf: 'double ') -> "void":
	return _npstat.GridRandomizer_generate(self, uniformRandomInput, bufLen, resultBuf)

	def __init__(self, *args):
	this = _npstat.new_GridRandomizer(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	GridRandomizer_swigregister = _npstat.GridRandomizer_swigregister
	GridRandomizer_swigregister(GridRandomizer)

	class UGaussConvolution1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UGaussConvolution1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UGaussConvolution1D, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double', scale: 'double', leftEdge: 'double', uniformWidth: 'double'):
	this = _npstat.new_UGaussConvolution1D(location, scale, leftEdge, uniformWidth)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::UGaussConvolution1D *":
	return _npstat.UGaussConvolution1D_clone(self)
	__swig_destroy__ = _npstat.delete_UGaussConvolution1D
	__del__ = lambda self: None

	def leftEdge(self) -> "double":
	return _npstat.UGaussConvolution1D_leftEdge(self)

	def uniformWidth(self) -> "double":
	return _npstat.UGaussConvolution1D_uniformWidth(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.UGaussConvolution1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.UGaussConvolution1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.UGaussConvolution1D_classname)
	else:
	classname = _npstat.UGaussConvolution1D_classname
	if _newclass:
	version = staticmethod(_npstat.UGaussConvolution1D_version)
	else:
	version = _npstat.UGaussConvolution1D_version
	if _newclass:
	read = staticmethod(_npstat.UGaussConvolution1D_read)
	else:
	read = _npstat.UGaussConvolution1D_read
	UGaussConvolution1D_swigregister = _npstat.UGaussConvolution1D_swigregister
	UGaussConvolution1D_swigregister(UGaussConvolution1D)

	def UGaussConvolution1D_classname() -> "char const *":
	return _npstat.UGaussConvolution1D_classname()
	UGaussConvolution1D_classname = _npstat.UGaussConvolution1D_classname

	def UGaussConvolution1D_version() -> "unsigned int":
	return _npstat.UGaussConvolution1D_version()
	UGaussConvolution1D_version = _npstat.UGaussConvolution1D_version

	def UGaussConvolution1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::UGaussConvolution1D *":
	return _npstat.UGaussConvolution1D_read(id, arg3)
	UGaussConvolution1D_read = _npstat.UGaussConvolution1D_read

	class JohnsonSu(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, JohnsonSu, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, JohnsonSu, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double', scale: 'double', skewness: 'double', kurtosis: 'double'):
	this = _npstat.new_JohnsonSu(location, scale, skewness, kurtosis)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::JohnsonSu *":
	return _npstat.JohnsonSu_clone(self)
	__swig_destroy__ = _npstat.delete_JohnsonSu
	__del__ = lambda self: None

	def skewness(self) -> "double":
	return _npstat.JohnsonSu_skewness(self)

	def kurtosis(self) -> "double":
	return _npstat.JohnsonSu_kurtosis(self)

	def isValid(self) -> "bool":
	return _npstat.JohnsonSu_isValid(self)

	def getDelta(self) -> "double":
	return _npstat.JohnsonSu_getDelta(self)

	def getLambda(self) -> "double":
	return _npstat.JohnsonSu_getLambda(self)

	def getGamma(self) -> "double":
	return _npstat.JohnsonSu_getGamma(self)

	def getXi(self) -> "double":
	return _npstat.JohnsonSu_getXi(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.JohnsonSu_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.JohnsonSu_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.JohnsonSu_classname)
	else:
	classname = _npstat.JohnsonSu_classname
	if _newclass:
	version = staticmethod(_npstat.JohnsonSu_version)
	else:
	version = _npstat.JohnsonSu_version
	if _newclass:
	read = staticmethod(_npstat.JohnsonSu_read)
	else:
	read = _npstat.JohnsonSu_read
	JohnsonSu_swigregister = _npstat.JohnsonSu_swigregister
	JohnsonSu_swigregister(JohnsonSu)

	def JohnsonSu_classname() -> "char const *":
	return _npstat.JohnsonSu_classname()
	JohnsonSu_classname = _npstat.JohnsonSu_classname

	def JohnsonSu_version() -> "unsigned int":
	return _npstat.JohnsonSu_version()
	JohnsonSu_version = _npstat.JohnsonSu_version

	def JohnsonSu_read(id: 'ClassId', arg3: 'istream') -> "npstat::JohnsonSu *":
	return _npstat.JohnsonSu_read(id, arg3)
	JohnsonSu_read = _npstat.JohnsonSu_read

	class JohnsonSb(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, JohnsonSb, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, JohnsonSb, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double', scale: 'double', skewness: 'double', kurtosis: 'double'):
	this = _npstat.new_JohnsonSb(location, scale, skewness, kurtosis)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::JohnsonSb *":
	return _npstat.JohnsonSb_clone(self)
	__swig_destroy__ = _npstat.delete_JohnsonSb
	__del__ = lambda self: None

	def skewness(self) -> "double":
	return _npstat.JohnsonSb_skewness(self)

	def kurtosis(self) -> "double":
	return _npstat.JohnsonSb_kurtosis(self)

	def isValid(self) -> "bool":
	return _npstat.JohnsonSb_isValid(self)

	def getDelta(self) -> "double":
	return _npstat.JohnsonSb_getDelta(self)

	def getLambda(self) -> "double":
	return _npstat.JohnsonSb_getLambda(self)

	def getGamma(self) -> "double":
	return _npstat.JohnsonSb_getGamma(self)

	def getXi(self) -> "double":
	return _npstat.JohnsonSb_getXi(self)
	if _newclass:
	fitParameters = staticmethod(_npstat.JohnsonSb_fitParameters)
	else:
	fitParameters = _npstat.JohnsonSb_fitParameters

	def classId(self) -> "gs::ClassId":
	return _npstat.JohnsonSb_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.JohnsonSb_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.JohnsonSb_classname)
	else:
	classname = _npstat.JohnsonSb_classname
	if _newclass:
	version = staticmethod(_npstat.JohnsonSb_version)
	else:
	version = _npstat.JohnsonSb_version
	if _newclass:
	read = staticmethod(_npstat.JohnsonSb_read)
	else:
	read = _npstat.JohnsonSb_read
	JohnsonSb_swigregister = _npstat.JohnsonSb_swigregister
	JohnsonSb_swigregister(JohnsonSb)

	def JohnsonSb_fitParameters(skewness: 'double', kurtosis: 'double', gamma: 'double ', delta: 'double ', arg6: 'double ', xi: 'double ') -> "bool":
	return _npstat.JohnsonSb_fitParameters(skewness, kurtosis, gamma, delta, arg6, xi)
	JohnsonSb_fitParameters = _npstat.JohnsonSb_fitParameters

	def JohnsonSb_classname() -> "char const *":
	return _npstat.JohnsonSb_classname()
	JohnsonSb_classname = _npstat.JohnsonSb_classname

	def JohnsonSb_version() -> "unsigned int":
	return _npstat.JohnsonSb_version()
	JohnsonSb_version = _npstat.JohnsonSb_version

	def JohnsonSb_read(id: 'ClassId', arg3: 'istream') -> "npstat::JohnsonSb *":
	return _npstat.JohnsonSb_read(id, arg3)
	JohnsonSb_read = _npstat.JohnsonSb_read

	class JohnsonSystem(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, JohnsonSystem, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, JohnsonSystem, name)
	__repr__ = _swig_repr
	GAUSSIAN = _npstat.JohnsonSystem_GAUSSIAN
	LOGNORMAL = _npstat.JohnsonSystem_LOGNORMAL
	SU = _npstat.JohnsonSystem_SU
	SB = _npstat.JohnsonSystem_SB
	INVALID = _npstat.JohnsonSystem_INVALID

	def __init__(self, *args):
	this = _npstat.new_JohnsonSystem(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_JohnsonSystem
	__del__ = lambda self: None

	def clone(self) -> "npstat::JohnsonSystem *":
	return _npstat.JohnsonSystem_clone(self)

	def skewness(self) -> "double":
	return _npstat.JohnsonSystem_skewness(self)

	def kurtosis(self) -> "double":
	return _npstat.JohnsonSystem_kurtosis(self)

	def curveType(self) -> "npstat::JohnsonSystem::CurveType":
	return _npstat.JohnsonSystem_curveType(self)

	def isValid(self) -> "bool":
	return _npstat.JohnsonSystem_isValid(self)
	if _newclass:
	select = staticmethod(_npstat.JohnsonSystem_select)
	else:
	select = _npstat.JohnsonSystem_select

	def classId(self) -> "gs::ClassId":
	return _npstat.JohnsonSystem_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.JohnsonSystem_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.JohnsonSystem_classname)
	else:
	classname = _npstat.JohnsonSystem_classname
	if _newclass:
	version = staticmethod(_npstat.JohnsonSystem_version)
	else:
	version = _npstat.JohnsonSystem_version
	if _newclass:
	read = staticmethod(_npstat.JohnsonSystem_read)
	else:
	read = _npstat.JohnsonSystem_read
	JohnsonSystem_swigregister = _npstat.JohnsonSystem_swigregister
	JohnsonSystem_swigregister(JohnsonSystem)

	def JohnsonSystem_select(skewness: 'double', kurtosis: 'double') -> "npstat::JohnsonSystem::CurveType":
	return _npstat.JohnsonSystem_select(skewness, kurtosis)
	JohnsonSystem_select = _npstat.JohnsonSystem_select

	def JohnsonSystem_classname() -> "char const *":
	return _npstat.JohnsonSystem_classname()
	JohnsonSystem_classname = _npstat.JohnsonSystem_classname

	def JohnsonSystem_version() -> "unsigned int":
	return _npstat.JohnsonSystem_version()
	JohnsonSystem_version = _npstat.JohnsonSystem_version

	def JohnsonSystem_read(id: 'ClassId', arg3: 'istream') -> "npstat::JohnsonSystem *":
	return _npstat.JohnsonSystem_read(id, arg3)
	JohnsonSystem_read = _npstat.JohnsonSystem_read

	EIGEN_SIMPLE = _npstat.EIGEN_SIMPLE
	EIGEN_D_AND_C = _npstat.EIGEN_D_AND_C
	EIGEN_RRR = _npstat.EIGEN_RRR

	def parseEigenMethod(methodName: 'char const *') -> "npstat::EigenMethod":
	return _npstat.parseEigenMethod(methodName)
	parseEigenMethod = _npstat.parseEigenMethod

	def eigenMethodName(m: 'npstat::EigenMethod') -> "char const *":
	return _npstat.eigenMethodName(m)
	eigenMethodName = _npstat.eigenMethodName

	def validEigenMethodNames() -> "std::string":
	return _npstat.validEigenMethodNames()
	validEigenMethodNames = _npstat.validEigenMethodNames
	SVD_SIMPLE = _npstat.SVD_SIMPLE
	SVD_D_AND_C = _npstat.SVD_D_AND_C

	def parseSvdMethod(methodName: 'char const *') -> "npstat::SvdMethod":
	return _npstat.parseSvdMethod(methodName)
	parseSvdMethod = _npstat.parseSvdMethod

	def svdMethodName(m: 'npstat::SvdMethod') -> "char const *":
	return _npstat.svdMethodName(m)
	svdMethodName = _npstat.svdMethodName

	def validSvdMethodNames() -> "std::string":
	return _npstat.validSvdMethodNames()
	validSvdMethodNames = _npstat.validSvdMethodNames
	class FloatMatrix(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatMatrix, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatMatrix, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatMatrix
	__del__ = lambda self: None

	def tagAsDiagonal(self) -> "npstat::Matrix< float > &":
	return _npstat.FloatMatrix_tagAsDiagonal(self)

	def nRows(self) -> "unsigned int":
	return _npstat.FloatMatrix_nRows(self)

	def nColumns(self) -> "unsigned int":
	return _npstat.FloatMatrix_nColumns(self)

	def length(self) -> "unsigned int":
	return _npstat.FloatMatrix_length(self)

	def data(self) -> "float *":
	return _npstat.FloatMatrix_data(self)

	def isSquare(self) -> "bool":
	return _npstat.FloatMatrix_isSquare(self)

	def isSymmetric(self) -> "bool":
	return _npstat.FloatMatrix_isSymmetric(self)

	def isAntiSymmetric(self) -> "bool":
	return _npstat.FloatMatrix_isAntiSymmetric(self)

	def isDiagonal(self) -> "bool":
	return _npstat.FloatMatrix_isDiagonal(self)

	def uninitialize(self) -> "npstat::Matrix< float > &":
	return _npstat.FloatMatrix_uninitialize(self)

	def isCompatible(self, other: 'FloatMatrix') -> "bool":
	return _npstat.FloatMatrix_isCompatible(self, other)

	def resize(self, nrows: 'unsigned int', ncols: 'unsigned int') -> "npstat::Matrix< float > &":
	return _npstat.FloatMatrix_resize(self, nrows, ncols)

	def zeroOut(self) -> "npstat::Matrix< float > &":
	return _npstat.FloatMatrix_zeroOut(self)

	def clearMainDiagonal(self) -> "npstat::Matrix< float > &":
	return _npstat.FloatMatrix_clearMainDiagonal(self)

	def makeDiagonal(self) -> "npstat::Matrix< float > &":
	return _npstat.FloatMatrix_makeDiagonal(self)

	def constFill(self, c: 'float') -> "npstat::Matrix< float > &":
	return _npstat.FloatMatrix_constFill(self, c)

	def Tthis(self) -> "npstat::Matrix< float > &":
	return _npstat.FloatMatrix_Tthis(self)

	def __eq__(self, arg2: 'FloatMatrix') -> "bool":
	return _npstat.FloatMatrix___eq__(self, arg2)

	def __ne__(self, arg2: 'FloatMatrix') -> "bool":
	return _npstat.FloatMatrix___ne__(self, arg2)

	def set(self, row: 'unsigned int', column: 'unsigned int', value: 'float') -> "npstat::Matrix< float > &":
	return _npstat.FloatMatrix_set(self, row, column, value)

	def __call__(self, row: 'unsigned int', column: 'unsigned int') -> "float":
	return _npstat.FloatMatrix___call__(self, row, column)

	def rowSum(self, row: 'unsigned int') -> "float":
	return _npstat.FloatMatrix_rowSum(self, row)

	def columnSum(self, column: 'unsigned int') -> "float":
	return _npstat.FloatMatrix_columnSum(self, column)

	def removeRowAndColumn(self, row: 'unsigned int', column: 'unsigned int') -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_removeRowAndColumn(self, row, column)

	def nonZeros(self) -> "unsigned int":
	return _npstat.FloatMatrix_nonZeros(self)

	def coarseSum(self, n: 'unsigned int', m: 'unsigned int', result: 'FloatMatrix') -> "void":
	return _npstat.FloatMatrix_coarseSum(self, n, m, result)

	def coarseAverage(self, n: 'unsigned int', m: 'unsigned int', result: 'FloatMatrix') -> "void":
	return _npstat.FloatMatrix_coarseAverage(self, n, m, result)

	def __pos__(self) -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix___pos__(self)

	def __neg__(self) -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix___neg__(self)

	def __mul__(self, *args) -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix___mul__(self, *args)

	def __truediv__(self, *args):
	return _npstat.FloatMatrix___truediv__(self, *args)
	__div__ = __truediv__



	def __add__(self, r: 'FloatMatrix') -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix___add__(self, r)

	def __sub__(self, r: 'FloatMatrix') -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix___sub__(self, r)

	def hadamardProduct(self, r: 'FloatMatrix') -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_hadamardProduct(self, r)

	def hadamardRatio(self, denominator: 'FloatMatrix') -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_hadamardRatio(self, denominator)

	def times(self, *args) -> "void":
	return _npstat.FloatMatrix_times(self, *args)

	def over(self, r: 'float', result: 'FloatMatrix') -> "void":
	return _npstat.FloatMatrix_over(self, r, result)

	def plus(self, r: 'FloatMatrix', result: 'FloatMatrix') -> "void":
	return _npstat.FloatMatrix_plus(self, r, result)

	def minus(self, r: 'FloatMatrix', result: 'FloatMatrix') -> "void":
	return _npstat.FloatMatrix_minus(self, r, result)

	def __imul__(self, r: 'float') -> "npstat::Matrix< float > &":
	return _npstat.FloatMatrix___imul__(self, r)

	def __itruediv__(self, *args):
	return _npstat.FloatMatrix___itruediv__(self, *args)
	__idiv__ = __itruediv__



	def __iadd__(self, r: 'FloatMatrix') -> "npstat::Matrix< float > &":
	return _npstat.FloatMatrix___iadd__(self, r)

	def __isub__(self, r: 'FloatMatrix') -> "npstat::Matrix< float > &":
	return _npstat.FloatMatrix___isub__(self, r)

	def bilinearT(self, r: 'FloatMatrix') -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_bilinearT(self, r)

	def solveLinearSystems(self, RHS: 'FloatMatrix', X: 'FloatMatrix') -> "bool":
	return _npstat.FloatMatrix_solveLinearSystems(self, RHS, X)

	def underdeterminedLinearSystem(self, rhs: 'float const ', lenRhs: 'unsigned int', V: 'FloatMatrix', solution: 'float ', lenSolution: 'unsigned int', resultNormSquared: 'float *'=None, A: 'FloatMatrix'=None) -> "bool":
	return _npstat.FloatMatrix_underdeterminedLinearSystem(self, rhs, lenRhs, V, solution, lenSolution, resultNormSquared, A)

	def linearLeastSquares(self, rhs: 'float const ', lenRhs: 'unsigned int', solution: 'float ', lenSolution: 'unsigned int') -> "bool":
	return _npstat.FloatMatrix_linearLeastSquares(self, rhs, lenRhs, solution, lenSolution)

	def constrainedLeastSquares(self, rhs1: 'float const ', lenRhs1: 'unsigned int', B: 'FloatMatrix', rhs2: 'float const ', lenRhs2: 'unsigned int', solution: 'float ', lenSol: 'unsigned int', resultChiSquare: 'float '=None, resultCovarianceMatrix: 'FloatMatrix'=None, unconstrainedSolution: 'float *'=None, unconstrainedCovmat: 'FloatMatrix'=None, projectionMatrix: 'FloatMatrix'=None, A: 'FloatMatrix'=None) -> "bool":
	return _npstat.FloatMatrix_constrainedLeastSquares(self, rhs1, lenRhs1, B, rhs2, lenRhs2, solution, lenSol, resultChiSquare, resultCovarianceMatrix, unconstrainedSolution, unconstrainedCovmat, projectionMatrix, A)

	def weightedLeastSquares(self, rhs: 'float const ', lenRhs: 'unsigned int', inverseCovarianceMatrix: 'FloatMatrix', solution: 'float ', lenSolution: 'unsigned int', resultChiSquare: 'float *'=None, resultCovarianceMatrix: 'FloatMatrix'=None) -> "bool":
	return _npstat.FloatMatrix_weightedLeastSquares(self, rhs, lenRhs, inverseCovarianceMatrix, solution, lenSolution, resultChiSquare, resultCovarianceMatrix)

	def T(self) -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_T(self)

	def TtimesThis(self) -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_TtimesThis(self)

	def timesT(self, *args) -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_timesT(self, *args)

	def Ttimes(self, r: 'FloatMatrix') -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_Ttimes(self, r)

	def directSum(self, added: 'FloatMatrix') -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_directSum(self, added)

	def symmetrize(self) -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_symmetrize(self)

	def antiSymmetrize(self) -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_antiSymmetrize(self)

	def outer(self, r: 'FloatMatrix') -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_outer(self, r)

	def maxAbsValue(self) -> "float":
	return _npstat.FloatMatrix_maxAbsValue(self)

	def frobeniusNorm(self) -> "double":
	return _npstat.FloatMatrix_frobeniusNorm(self)

	def tr(self) -> "float":
	return _npstat.FloatMatrix_tr(self)

	def sp(self) -> "float":
	return _npstat.FloatMatrix_sp(self)

	def productTr(self, r: 'FloatMatrix') -> "float":
	return _npstat.FloatMatrix_productTr(self, r)

	def productSp(self, r: 'FloatMatrix') -> "float":
	return _npstat.FloatMatrix_productSp(self, r)

	def det(self) -> "float":
	return _npstat.FloatMatrix_det(self)

	def symPDInv(self) -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_symPDInv(self)

	def symPDEigenInv(self, *args) -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_symPDEigenInv(self, *args)

	def symInv(self) -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_symInv(self)

	def inv(self) -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_inv(self)

	def tdSymEigen(self, *args) -> "void":
	return _npstat.FloatMatrix_tdSymEigen(self, *args)

	def svd(self, *args) -> "void":
	return _npstat.FloatMatrix_svd(self, *args)

	def symPSDefEffectiveRank(self, *args) -> "double":
	return _npstat.FloatMatrix_symPSDefEffectiveRank(self, *args)

	def pow(self, degree: 'unsigned int') -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_pow(self, degree)

	def covarToCorr(self) -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_covarToCorr(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatMatrix_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatMatrix_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatMatrix_classname)
	else:
	classname = _npstat.FloatMatrix_classname
	if _newclass:
	version = staticmethod(_npstat.FloatMatrix_version)
	else:
	version = _npstat.FloatMatrix_version
	if _newclass:
	restore = staticmethod(_npstat.FloatMatrix_restore)
	else:
	restore = _npstat.FloatMatrix_restore

	def timesVector(self, data: 'float const *') -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_timesVector(self, data)

	def rowMultiply(self, data: 'float const *') -> "npstat::Matrix< float >":
	return _npstat.FloatMatrix_rowMultiply(self, data)

	def bilinear(self, *args) -> "float":
	return _npstat.FloatMatrix_bilinear(self, *args)

	def solveLinearSystem(self, data: 'float const *') -> "std::vector< float,std::allocator< float > >":
	return _npstat.FloatMatrix_solveLinearSystem(self, data)

	def symEigenValues(self) -> "std::vector< float,std::allocator< float > >":
	return _npstat.FloatMatrix_symEigenValues(self)

	def __init__(self, *args):
	this = _npstat.new_FloatMatrix(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	FloatMatrix_swigregister = _npstat.FloatMatrix_swigregister
	FloatMatrix_swigregister(FloatMatrix)

	def FloatMatrix_classname() -> "char const *":
	return _npstat.FloatMatrix_classname()
	FloatMatrix_classname = _npstat.FloatMatrix_classname

	def FloatMatrix_version() -> "unsigned int":
	return _npstat.FloatMatrix_version()
	FloatMatrix_version = _npstat.FloatMatrix_version

	def FloatMatrix_restore(id: 'ClassId', arg3: 'istream', m: 'FloatMatrix') -> "void":
	return _npstat.FloatMatrix_restore(id, arg3, m)
	FloatMatrix_restore = _npstat.FloatMatrix_restore

	class DoubleMatrix(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleMatrix, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleMatrix, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleMatrix
	__del__ = lambda self: None

	def tagAsDiagonal(self) -> "npstat::Matrix< double > &":
	return _npstat.DoubleMatrix_tagAsDiagonal(self)

	def nRows(self) -> "unsigned int":
	return _npstat.DoubleMatrix_nRows(self)

	def nColumns(self) -> "unsigned int":
	return _npstat.DoubleMatrix_nColumns(self)

	def length(self) -> "unsigned int":
	return _npstat.DoubleMatrix_length(self)

	def data(self) -> "double *":
	return _npstat.DoubleMatrix_data(self)

	def isSquare(self) -> "bool":
	return _npstat.DoubleMatrix_isSquare(self)

	def isSymmetric(self) -> "bool":
	return _npstat.DoubleMatrix_isSymmetric(self)

	def isAntiSymmetric(self) -> "bool":
	return _npstat.DoubleMatrix_isAntiSymmetric(self)

	def isDiagonal(self) -> "bool":
	return _npstat.DoubleMatrix_isDiagonal(self)

	def uninitialize(self) -> "npstat::Matrix< double > &":
	return _npstat.DoubleMatrix_uninitialize(self)

	def isCompatible(self, other: 'DoubleMatrix') -> "bool":
	return _npstat.DoubleMatrix_isCompatible(self, other)

	def resize(self, nrows: 'unsigned int', ncols: 'unsigned int') -> "npstat::Matrix< double > &":
	return _npstat.DoubleMatrix_resize(self, nrows, ncols)

	def zeroOut(self) -> "npstat::Matrix< double > &":
	return _npstat.DoubleMatrix_zeroOut(self)

	def clearMainDiagonal(self) -> "npstat::Matrix< double > &":
	return _npstat.DoubleMatrix_clearMainDiagonal(self)

	def makeDiagonal(self) -> "npstat::Matrix< double > &":
	return _npstat.DoubleMatrix_makeDiagonal(self)

	def constFill(self, c: 'double') -> "npstat::Matrix< double > &":
	return _npstat.DoubleMatrix_constFill(self, c)

	def Tthis(self) -> "npstat::Matrix< double > &":
	return _npstat.DoubleMatrix_Tthis(self)

	def __eq__(self, arg2: 'DoubleMatrix') -> "bool":
	return _npstat.DoubleMatrix___eq__(self, arg2)

	def __ne__(self, arg2: 'DoubleMatrix') -> "bool":
	return _npstat.DoubleMatrix___ne__(self, arg2)

	def set(self, row: 'unsigned int', column: 'unsigned int', value: 'double') -> "npstat::Matrix< double > &":
	return _npstat.DoubleMatrix_set(self, row, column, value)

	def __call__(self, row: 'unsigned int', column: 'unsigned int') -> "double":
	return _npstat.DoubleMatrix___call__(self, row, column)

	def rowSum(self, row: 'unsigned int') -> "double":
	return _npstat.DoubleMatrix_rowSum(self, row)

	def columnSum(self, column: 'unsigned int') -> "double":
	return _npstat.DoubleMatrix_columnSum(self, column)

	def removeRowAndColumn(self, row: 'unsigned int', column: 'unsigned int') -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_removeRowAndColumn(self, row, column)

	def nonZeros(self) -> "unsigned int":
	return _npstat.DoubleMatrix_nonZeros(self)

	def coarseSum(self, n: 'unsigned int', m: 'unsigned int', result: 'DoubleMatrix') -> "void":
	return _npstat.DoubleMatrix_coarseSum(self, n, m, result)

	def coarseAverage(self, n: 'unsigned int', m: 'unsigned int', result: 'DoubleMatrix') -> "void":
	return _npstat.DoubleMatrix_coarseAverage(self, n, m, result)

	def __pos__(self) -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix___pos__(self)

	def __neg__(self) -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix___neg__(self)

	def __mul__(self, *args) -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix___mul__(self, *args)

	def __truediv__(self, *args):
	return _npstat.DoubleMatrix___truediv__(self, *args)
	__div__ = __truediv__



	def __add__(self, r: 'DoubleMatrix') -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix___add__(self, r)

	def __sub__(self, r: 'DoubleMatrix') -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix___sub__(self, r)

	def hadamardProduct(self, r: 'DoubleMatrix') -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_hadamardProduct(self, r)

	def hadamardRatio(self, denominator: 'DoubleMatrix') -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_hadamardRatio(self, denominator)

	def times(self, *args) -> "void":
	return _npstat.DoubleMatrix_times(self, *args)

	def over(self, r: 'double', result: 'DoubleMatrix') -> "void":
	return _npstat.DoubleMatrix_over(self, r, result)

	def plus(self, r: 'DoubleMatrix', result: 'DoubleMatrix') -> "void":
	return _npstat.DoubleMatrix_plus(self, r, result)

	def minus(self, r: 'DoubleMatrix', result: 'DoubleMatrix') -> "void":
	return _npstat.DoubleMatrix_minus(self, r, result)

	def __imul__(self, r: 'double') -> "npstat::Matrix< double > &":
	return _npstat.DoubleMatrix___imul__(self, r)

	def __itruediv__(self, *args):
	return _npstat.DoubleMatrix___itruediv__(self, *args)
	__idiv__ = __itruediv__



	def __iadd__(self, r: 'DoubleMatrix') -> "npstat::Matrix< double > &":
	return _npstat.DoubleMatrix___iadd__(self, r)

	def __isub__(self, r: 'DoubleMatrix') -> "npstat::Matrix< double > &":
	return _npstat.DoubleMatrix___isub__(self, r)

	def bilinearT(self, r: 'DoubleMatrix') -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_bilinearT(self, r)

	def solveLinearSystems(self, RHS: 'DoubleMatrix', X: 'DoubleMatrix') -> "bool":
	return _npstat.DoubleMatrix_solveLinearSystems(self, RHS, X)

	def underdeterminedLinearSystem(self, rhs: 'double const ', lenRhs: 'unsigned int', V: 'DoubleMatrix', solution: 'double ', lenSolution: 'unsigned int', resultNormSquared: 'double *'=None, A: 'DoubleMatrix'=None) -> "bool":
	return _npstat.DoubleMatrix_underdeterminedLinearSystem(self, rhs, lenRhs, V, solution, lenSolution, resultNormSquared, A)

	def linearLeastSquares(self, rhs: 'double const ', lenRhs: 'unsigned int', solution: 'double ', lenSolution: 'unsigned int') -> "bool":
	return _npstat.DoubleMatrix_linearLeastSquares(self, rhs, lenRhs, solution, lenSolution)

	def constrainedLeastSquares(self, rhs1: 'double const ', lenRhs1: 'unsigned int', B: 'DoubleMatrix', rhs2: 'double const ', lenRhs2: 'unsigned int', solution: 'double ', lenSol: 'unsigned int', resultChiSquare: 'double '=None, resultCovarianceMatrix: 'DoubleMatrix'=None, unconstrainedSolution: 'double *'=None, unconstrainedCovmat: 'DoubleMatrix'=None, projectionMatrix: 'DoubleMatrix'=None, A: 'DoubleMatrix'=None) -> "bool":
	return _npstat.DoubleMatrix_constrainedLeastSquares(self, rhs1, lenRhs1, B, rhs2, lenRhs2, solution, lenSol, resultChiSquare, resultCovarianceMatrix, unconstrainedSolution, unconstrainedCovmat, projectionMatrix, A)

	def weightedLeastSquares(self, rhs: 'double const ', lenRhs: 'unsigned int', inverseCovarianceMatrix: 'DoubleMatrix', solution: 'double ', lenSolution: 'unsigned int', resultChiSquare: 'double *'=None, resultCovarianceMatrix: 'DoubleMatrix'=None) -> "bool":
	return _npstat.DoubleMatrix_weightedLeastSquares(self, rhs, lenRhs, inverseCovarianceMatrix, solution, lenSolution, resultChiSquare, resultCovarianceMatrix)

	def T(self) -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_T(self)

	def TtimesThis(self) -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_TtimesThis(self)

	def timesT(self, *args) -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_timesT(self, *args)

	def Ttimes(self, r: 'DoubleMatrix') -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_Ttimes(self, r)

	def directSum(self, added: 'DoubleMatrix') -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_directSum(self, added)

	def symmetrize(self) -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_symmetrize(self)

	def antiSymmetrize(self) -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_antiSymmetrize(self)

	def outer(self, r: 'DoubleMatrix') -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_outer(self, r)

	def maxAbsValue(self) -> "double":
	return _npstat.DoubleMatrix_maxAbsValue(self)

	def frobeniusNorm(self) -> "double":
	return _npstat.DoubleMatrix_frobeniusNorm(self)

	def tr(self) -> "double":
	return _npstat.DoubleMatrix_tr(self)

	def sp(self) -> "double":
	return _npstat.DoubleMatrix_sp(self)

	def productTr(self, r: 'DoubleMatrix') -> "double":
	return _npstat.DoubleMatrix_productTr(self, r)

	def productSp(self, r: 'DoubleMatrix') -> "double":
	return _npstat.DoubleMatrix_productSp(self, r)

	def det(self) -> "double":
	return _npstat.DoubleMatrix_det(self)

	def symPDInv(self) -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_symPDInv(self)

	def symPDEigenInv(self, *args) -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_symPDEigenInv(self, *args)

	def symInv(self) -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_symInv(self)

	def inv(self) -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_inv(self)

	def tdSymEigen(self, *args) -> "void":
	return _npstat.DoubleMatrix_tdSymEigen(self, *args)

	def svd(self, *args) -> "void":
	return _npstat.DoubleMatrix_svd(self, *args)

	def symPSDefEffectiveRank(self, *args) -> "double":
	return _npstat.DoubleMatrix_symPSDefEffectiveRank(self, *args)

	def pow(self, degree: 'unsigned int') -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_pow(self, degree)

	def covarToCorr(self) -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_covarToCorr(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleMatrix_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleMatrix_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleMatrix_classname)
	else:
	classname = _npstat.DoubleMatrix_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleMatrix_version)
	else:
	version = _npstat.DoubleMatrix_version
	if _newclass:
	restore = staticmethod(_npstat.DoubleMatrix_restore)
	else:
	restore = _npstat.DoubleMatrix_restore

	def timesVector(self, data: 'double const *') -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_timesVector(self, data)

	def rowMultiply(self, data: 'double const *') -> "npstat::Matrix< double >":
	return _npstat.DoubleMatrix_rowMultiply(self, data)

	def bilinear(self, *args) -> "double":
	return _npstat.DoubleMatrix_bilinear(self, *args)

	def solveLinearSystem(self, data: 'double const *') -> "std::vector< double,std::allocator< double > >":
	return _npstat.DoubleMatrix_solveLinearSystem(self, data)

	def symEigenValues(self) -> "std::vector< double,std::allocator< double > >":
	return _npstat.DoubleMatrix_symEigenValues(self)

	def __init__(self, *args):
	this = _npstat.new_DoubleMatrix(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def symEigenSystem(self) -> "std::pair< std::vector< double,std::allocator< double > >,npstat::Matrix< double,16 > >":
	return _npstat.DoubleMatrix_symEigenSystem(self)
	DoubleMatrix_swigregister = _npstat.DoubleMatrix_swigregister
	DoubleMatrix_swigregister(DoubleMatrix)

	def DoubleMatrix_classname() -> "char const *":
	return _npstat.DoubleMatrix_classname()
	DoubleMatrix_classname = _npstat.DoubleMatrix_classname

	def DoubleMatrix_version() -> "unsigned int":
	return _npstat.DoubleMatrix_version()
	DoubleMatrix_version = _npstat.DoubleMatrix_version

	def DoubleMatrix_restore(id: 'ClassId', arg3: 'istream', m: 'DoubleMatrix') -> "void":
	return _npstat.DoubleMatrix_restore(id, arg3, m)
	DoubleMatrix_restore = _npstat.DoubleMatrix_restore

	def Matrix(*args):
	val = _npstat.new_Matrix(*args)
	return val

	class LDoubleMatrix(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LDoubleMatrix, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LDoubleMatrix, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LDoubleMatrix
	__del__ = lambda self: None

	def tagAsDiagonal(self) -> "npstat::Matrix< long double > &":
	return _npstat.LDoubleMatrix_tagAsDiagonal(self)

	def nRows(self) -> "unsigned int":
	return _npstat.LDoubleMatrix_nRows(self)

	def nColumns(self) -> "unsigned int":
	return _npstat.LDoubleMatrix_nColumns(self)

	def length(self) -> "unsigned int":
	return _npstat.LDoubleMatrix_length(self)

	def data(self) -> "long double *":
	return _npstat.LDoubleMatrix_data(self)

	def isSquare(self) -> "bool":
	return _npstat.LDoubleMatrix_isSquare(self)

	def isSymmetric(self) -> "bool":
	return _npstat.LDoubleMatrix_isSymmetric(self)

	def isAntiSymmetric(self) -> "bool":
	return _npstat.LDoubleMatrix_isAntiSymmetric(self)

	def isDiagonal(self) -> "bool":
	return _npstat.LDoubleMatrix_isDiagonal(self)

	def uninitialize(self) -> "npstat::Matrix< long double > &":
	return _npstat.LDoubleMatrix_uninitialize(self)

	def isCompatible(self, other: 'LDoubleMatrix') -> "bool":
	return _npstat.LDoubleMatrix_isCompatible(self, other)

	def resize(self, nrows: 'unsigned int', ncols: 'unsigned int') -> "npstat::Matrix< long double > &":
	return _npstat.LDoubleMatrix_resize(self, nrows, ncols)

	def zeroOut(self) -> "npstat::Matrix< long double > &":
	return _npstat.LDoubleMatrix_zeroOut(self)

	def clearMainDiagonal(self) -> "npstat::Matrix< long double > &":
	return _npstat.LDoubleMatrix_clearMainDiagonal(self)

	def makeDiagonal(self) -> "npstat::Matrix< long double > &":
	return _npstat.LDoubleMatrix_makeDiagonal(self)

	def constFill(self, c: 'long double') -> "npstat::Matrix< long double > &":
	return _npstat.LDoubleMatrix_constFill(self, c)

	def Tthis(self) -> "npstat::Matrix< long double > &":
	return _npstat.LDoubleMatrix_Tthis(self)

	def __eq__(self, arg2: 'LDoubleMatrix') -> "bool":
	return _npstat.LDoubleMatrix___eq__(self, arg2)

	def __ne__(self, arg2: 'LDoubleMatrix') -> "bool":
	return _npstat.LDoubleMatrix___ne__(self, arg2)

	def set(self, row: 'unsigned int', column: 'unsigned int', value: 'long double') -> "npstat::Matrix< long double > &":
	return _npstat.LDoubleMatrix_set(self, row, column, value)

	def __call__(self, row: 'unsigned int', column: 'unsigned int') -> "long double":
	return _npstat.LDoubleMatrix___call__(self, row, column)

	def rowSum(self, row: 'unsigned int') -> "long double":
	return _npstat.LDoubleMatrix_rowSum(self, row)

	def columnSum(self, column: 'unsigned int') -> "long double":
	return _npstat.LDoubleMatrix_columnSum(self, column)

	def removeRowAndColumn(self, row: 'unsigned int', column: 'unsigned int') -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_removeRowAndColumn(self, row, column)

	def nonZeros(self) -> "unsigned int":
	return _npstat.LDoubleMatrix_nonZeros(self)

	def coarseSum(self, n: 'unsigned int', m: 'unsigned int', result: 'LDoubleMatrix') -> "void":
	return _npstat.LDoubleMatrix_coarseSum(self, n, m, result)

	def coarseAverage(self, n: 'unsigned int', m: 'unsigned int', result: 'LDoubleMatrix') -> "void":
	return _npstat.LDoubleMatrix_coarseAverage(self, n, m, result)

	def __pos__(self) -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix___pos__(self)

	def __neg__(self) -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix___neg__(self)

	def __mul__(self, *args) -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix___mul__(self, *args)

	def __truediv__(self, *args):
	return _npstat.LDoubleMatrix___truediv__(self, *args)
	__div__ = __truediv__



	def __add__(self, r: 'LDoubleMatrix') -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix___add__(self, r)

	def __sub__(self, r: 'LDoubleMatrix') -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix___sub__(self, r)

	def hadamardProduct(self, r: 'LDoubleMatrix') -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_hadamardProduct(self, r)

	def hadamardRatio(self, denominator: 'LDoubleMatrix') -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_hadamardRatio(self, denominator)

	def times(self, *args) -> "void":
	return _npstat.LDoubleMatrix_times(self, *args)

	def over(self, r: 'long double', result: 'LDoubleMatrix') -> "void":
	return _npstat.LDoubleMatrix_over(self, r, result)

	def plus(self, r: 'LDoubleMatrix', result: 'LDoubleMatrix') -> "void":
	return _npstat.LDoubleMatrix_plus(self, r, result)

	def minus(self, r: 'LDoubleMatrix', result: 'LDoubleMatrix') -> "void":
	return _npstat.LDoubleMatrix_minus(self, r, result)

	def __imul__(self, r: 'long double') -> "npstat::Matrix< long double > &":
	return _npstat.LDoubleMatrix___imul__(self, r)

	def __itruediv__(self, *args):
	return _npstat.LDoubleMatrix___itruediv__(self, *args)
	__idiv__ = __itruediv__



	def __iadd__(self, r: 'LDoubleMatrix') -> "npstat::Matrix< long double > &":
	return _npstat.LDoubleMatrix___iadd__(self, r)

	def __isub__(self, r: 'LDoubleMatrix') -> "npstat::Matrix< long double > &":
	return _npstat.LDoubleMatrix___isub__(self, r)

	def bilinearT(self, r: 'LDoubleMatrix') -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_bilinearT(self, r)

	def solveLinearSystems(self, RHS: 'LDoubleMatrix', X: 'LDoubleMatrix') -> "bool":
	return _npstat.LDoubleMatrix_solveLinearSystems(self, RHS, X)

	def underdeterminedLinearSystem(self, rhs: 'long double const ', lenRhs: 'unsigned int', V: 'LDoubleMatrix', solution: 'long double ', lenSolution: 'unsigned int', resultNormSquared: 'long double *'=None, A: 'LDoubleMatrix'=None) -> "bool":
	return _npstat.LDoubleMatrix_underdeterminedLinearSystem(self, rhs, lenRhs, V, solution, lenSolution, resultNormSquared, A)

	def linearLeastSquares(self, rhs: 'long double const ', lenRhs: 'unsigned int', solution: 'long double ', lenSolution: 'unsigned int') -> "bool":
	return _npstat.LDoubleMatrix_linearLeastSquares(self, rhs, lenRhs, solution, lenSolution)

	def constrainedLeastSquares(self, rhs1: 'long double const ', lenRhs1: 'unsigned int', B: 'LDoubleMatrix', rhs2: 'long double const ', lenRhs2: 'unsigned int', solution: 'long double ', lenSol: 'unsigned int', resultChiSquare: 'long double '=None, resultCovarianceMatrix: 'LDoubleMatrix'=None, unconstrainedSolution: 'long double *'=None, unconstrainedCovmat: 'LDoubleMatrix'=None, projectionMatrix: 'LDoubleMatrix'=None, A: 'LDoubleMatrix'=None) -> "bool":
	return _npstat.LDoubleMatrix_constrainedLeastSquares(self, rhs1, lenRhs1, B, rhs2, lenRhs2, solution, lenSol, resultChiSquare, resultCovarianceMatrix, unconstrainedSolution, unconstrainedCovmat, projectionMatrix, A)

	def weightedLeastSquares(self, rhs: 'long double const ', lenRhs: 'unsigned int', inverseCovarianceMatrix: 'LDoubleMatrix', solution: 'long double ', lenSolution: 'unsigned int', resultChiSquare: 'long double *'=None, resultCovarianceMatrix: 'LDoubleMatrix'=None) -> "bool":
	return _npstat.LDoubleMatrix_weightedLeastSquares(self, rhs, lenRhs, inverseCovarianceMatrix, solution, lenSolution, resultChiSquare, resultCovarianceMatrix)

	def T(self) -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_T(self)

	def TtimesThis(self) -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_TtimesThis(self)

	def timesT(self, *args) -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_timesT(self, *args)

	def Ttimes(self, r: 'LDoubleMatrix') -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_Ttimes(self, r)

	def directSum(self, added: 'LDoubleMatrix') -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_directSum(self, added)

	def symmetrize(self) -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_symmetrize(self)

	def antiSymmetrize(self) -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_antiSymmetrize(self)

	def outer(self, r: 'LDoubleMatrix') -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_outer(self, r)

	def maxAbsValue(self) -> "long double":
	return _npstat.LDoubleMatrix_maxAbsValue(self)

	def frobeniusNorm(self) -> "double":
	return _npstat.LDoubleMatrix_frobeniusNorm(self)

	def tr(self) -> "long double":
	return _npstat.LDoubleMatrix_tr(self)

	def sp(self) -> "long double":
	return _npstat.LDoubleMatrix_sp(self)

	def productTr(self, r: 'LDoubleMatrix') -> "long double":
	return _npstat.LDoubleMatrix_productTr(self, r)

	def productSp(self, r: 'LDoubleMatrix') -> "long double":
	return _npstat.LDoubleMatrix_productSp(self, r)

	def det(self) -> "long double":
	return _npstat.LDoubleMatrix_det(self)

	def symPDInv(self) -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_symPDInv(self)

	def symPDEigenInv(self, *args) -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_symPDEigenInv(self, *args)

	def symInv(self) -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_symInv(self)

	def inv(self) -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_inv(self)

	def tdSymEigen(self, *args) -> "void":
	return _npstat.LDoubleMatrix_tdSymEigen(self, *args)

	def svd(self, *args) -> "void":
	return _npstat.LDoubleMatrix_svd(self, *args)

	def symPSDefEffectiveRank(self, *args) -> "double":
	return _npstat.LDoubleMatrix_symPSDefEffectiveRank(self, *args)

	def pow(self, degree: 'unsigned int') -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_pow(self, degree)

	def covarToCorr(self) -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_covarToCorr(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.LDoubleMatrix_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.LDoubleMatrix_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.LDoubleMatrix_classname)
	else:
	classname = _npstat.LDoubleMatrix_classname
	if _newclass:
	version = staticmethod(_npstat.LDoubleMatrix_version)
	else:
	version = _npstat.LDoubleMatrix_version
	if _newclass:
	restore = staticmethod(_npstat.LDoubleMatrix_restore)
	else:
	restore = _npstat.LDoubleMatrix_restore

	def timesVector(self, data: 'long double const *', dataLen: 'unsigned int') -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_timesVector(self, data, dataLen)

	def rowMultiply(self, data: 'long double const *', dataLen: 'unsigned int') -> "npstat::Matrix< long double >":
	return _npstat.LDoubleMatrix_rowMultiply(self, data, dataLen)

	def bilinear(self, *args) -> "long double":
	return _npstat.LDoubleMatrix_bilinear(self, *args)

	def solveLinearSystem(self, data: 'long double const *', dataLen: 'unsigned int') -> "std::vector< long double,std::allocator< long double > >":
	return _npstat.LDoubleMatrix_solveLinearSystem(self, data, dataLen)

	def symEigenValues(self) -> "std::vector< long double,std::allocator< long double > >":
	return _npstat.LDoubleMatrix_symEigenValues(self)

	def __init__(self, *args):
	this = _npstat.new_LDoubleMatrix(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	LDoubleMatrix_swigregister = _npstat.LDoubleMatrix_swigregister
	LDoubleMatrix_swigregister(LDoubleMatrix)

	def LDoubleMatrix_classname() -> "char const *":
	return _npstat.LDoubleMatrix_classname()
	LDoubleMatrix_classname = _npstat.LDoubleMatrix_classname

	def LDoubleMatrix_version() -> "unsigned int":
	return _npstat.LDoubleMatrix_version()
	LDoubleMatrix_version = _npstat.LDoubleMatrix_version

	def LDoubleMatrix_restore(id: 'ClassId', arg3: 'istream', m: 'LDoubleMatrix') -> "void":
	return _npstat.LDoubleMatrix_restore(id, arg3, m)
	LDoubleMatrix_restore = _npstat.LDoubleMatrix_restore


	def diag(*args) -> "npstat::Matrix< long double,16 >":
	return _npstat.diag(*args)
	diag = _npstat.diag
	class Eigensystem(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, Eigensystem, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, Eigensystem, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Eigensystem(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_setmethods__["first"] = _npstat.Eigensystem_first_set
	__swig_getmethods__["first"] = _npstat.Eigensystem_first_get
	if _newclass:
	first = _swig_property(_npstat.Eigensystem_first_get, _npstat.Eigensystem_first_set)
	__swig_setmethods__["second"] = _npstat.Eigensystem_second_set
	__swig_getmethods__["second"] = _npstat.Eigensystem_second_get
	if _newclass:
	second = _swig_property(_npstat.Eigensystem_second_get, _npstat.Eigensystem_second_set)
	def __len__(self):
	return 2
	def __repr__(self):
	return str((self.first, self.second))
	def __getitem__(self, index):
	if not (index % 2):
	return self.first
	else:
	return self.second
	def __setitem__(self, index, val):
	if not (index % 2):
	self.first = val
	else:
	self.second = val
	__swig_destroy__ = _npstat.delete_Eigensystem
	__del__ = lambda self: None
	Eigensystem_swigregister = _npstat.Eigensystem_swigregister
	Eigensystem_swigregister(Eigensystem)

	class ArchiveRecord_FloatMatrix(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_FloatMatrix, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_FloatMatrix, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'FloatMatrix', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_FloatMatrix(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_FloatMatrix
	__del__ = lambda self: None
	ArchiveRecord_FloatMatrix_swigregister = _npstat.ArchiveRecord_FloatMatrix_swigregister
	ArchiveRecord_FloatMatrix_swigregister(ArchiveRecord_FloatMatrix)

	class Ref_FloatMatrix(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_FloatMatrix, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_FloatMatrix, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_FloatMatrix(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'FloatMatrix') -> "void":
	return _npstat.Ref_FloatMatrix_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::Matrix< float,16 > *":
	return _npstat.Ref_FloatMatrix_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::Matrix< float,16 >":
	return _npstat.Ref_FloatMatrix_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_FloatMatrix
	__del__ = lambda self: None
	Ref_FloatMatrix_swigregister = _npstat.Ref_FloatMatrix_swigregister
	Ref_FloatMatrix_swigregister(Ref_FloatMatrix)

	class ArchiveRecord_DoubleMatrix(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DoubleMatrix, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DoubleMatrix, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DoubleMatrix', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DoubleMatrix(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DoubleMatrix
	__del__ = lambda self: None
	ArchiveRecord_DoubleMatrix_swigregister = _npstat.ArchiveRecord_DoubleMatrix_swigregister
	ArchiveRecord_DoubleMatrix_swigregister(ArchiveRecord_DoubleMatrix)

	class Ref_DoubleMatrix(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DoubleMatrix, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DoubleMatrix, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DoubleMatrix(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DoubleMatrix') -> "void":
	return _npstat.Ref_DoubleMatrix_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::Matrix< double,16 > *":
	return _npstat.Ref_DoubleMatrix_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::Matrix< double,16 >":
	return _npstat.Ref_DoubleMatrix_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DoubleMatrix
	__del__ = lambda self: None
	Ref_DoubleMatrix_swigregister = _npstat.Ref_DoubleMatrix_swigregister
	Ref_DoubleMatrix_swigregister(Ref_DoubleMatrix)

	class ArchiveRecord_LDoubleMatrix(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_LDoubleMatrix, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_LDoubleMatrix, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'LDoubleMatrix', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_LDoubleMatrix(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_LDoubleMatrix
	__del__ = lambda self: None
	ArchiveRecord_LDoubleMatrix_swigregister = _npstat.ArchiveRecord_LDoubleMatrix_swigregister
	ArchiveRecord_LDoubleMatrix_swigregister(ArchiveRecord_LDoubleMatrix)

	class Ref_LDoubleMatrix(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_LDoubleMatrix, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_LDoubleMatrix, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_LDoubleMatrix(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'LDoubleMatrix') -> "void":
	return _npstat.Ref_LDoubleMatrix_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::Matrix< long double,16 > *":
	return _npstat.Ref_LDoubleMatrix_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::Matrix< long double,16 >":
	return _npstat.Ref_LDoubleMatrix_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_LDoubleMatrix
	__del__ = lambda self: None
	Ref_LDoubleMatrix_swigregister = _npstat.Ref_LDoubleMatrix_swigregister
	Ref_LDoubleMatrix_swigregister(Ref_LDoubleMatrix)

	class ProductDistributionND(AbsDistributionND):
	__swig_setmethods__ = {}
	for _s in [AbsDistributionND]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ProductDistributionND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsDistributionND]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ProductDistributionND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_ProductDistributionND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ProductDistributionND
	__del__ = lambda self: None

	def clone(self) -> "npstat::ProductDistributionND *":
	return _npstat.ProductDistributionND_clone(self)

	def density(self, x: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.ProductDistributionND_density(self, x, dim)

	def unitMap(self, rnd: 'double const ', bufLen: 'unsigned int', x: 'double ') -> "void":
	return _npstat.ProductDistributionND_unitMap(self, rnd, bufLen, x)

	def mappedByQuantiles(self) -> "bool":
	return _npstat.ProductDistributionND_mappedByQuantiles(self)

	def isScalable(self) -> "bool":
	return _npstat.ProductDistributionND_isScalable(self)

	def getMarginal(self, i: 'unsigned int const') -> "npstat::AbsDistribution1D *":
	return _npstat.ProductDistributionND_getMarginal(self, i)

	def classId(self) -> "gs::ClassId":
	return _npstat.ProductDistributionND_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.ProductDistributionND_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.ProductDistributionND_classname)
	else:
	classname = _npstat.ProductDistributionND_classname
	if _newclass:
	version = staticmethod(_npstat.ProductDistributionND_version)
	else:
	version = _npstat.ProductDistributionND_version
	if _newclass:
	read = staticmethod(_npstat.ProductDistributionND_read)
	else:
	read = _npstat.ProductDistributionND_read
	ProductDistributionND_swigregister = _npstat.ProductDistributionND_swigregister
	ProductDistributionND_swigregister(ProductDistributionND)

	def ProductDistributionND_classname() -> "char const *":
	return _npstat.ProductDistributionND_classname()
	ProductDistributionND_classname = _npstat.ProductDistributionND_classname

	def ProductDistributionND_version() -> "unsigned int":
	return _npstat.ProductDistributionND_version()
	ProductDistributionND_version = _npstat.ProductDistributionND_version

	def ProductDistributionND_read(id: 'ClassId', arg3: 'istream') -> "npstat::ProductDistributionND *":
	return _npstat.ProductDistributionND_read(id, arg3)
	ProductDistributionND_read = _npstat.ProductDistributionND_read

	class UniformND(AbsScalableDistributionND):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistributionND]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UniformND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistributionND]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UniformND, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double const ', scale: 'double const ', dim: 'unsigned int const'):
	this = _npstat.new_UniformND(location, scale, dim)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UniformND
	__del__ = lambda self: None

	def clone(self) -> "npstat::UniformND *":
	return _npstat.UniformND_clone(self)

	def mappedByQuantiles(self) -> "bool":
	return _npstat.UniformND_mappedByQuantiles(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.UniformND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.UniformND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.UniformND_classname)
	else:
	classname = _npstat.UniformND_classname
	if _newclass:
	version = staticmethod(_npstat.UniformND_version)
	else:
	version = _npstat.UniformND_version
	if _newclass:
	read = staticmethod(_npstat.UniformND_read)
	else:
	read = _npstat.UniformND_read
	UniformND_swigregister = _npstat.UniformND_swigregister
	UniformND_swigregister(UniformND)

	def UniformND_classname() -> "char const *":
	return _npstat.UniformND_classname()
	UniformND_classname = _npstat.UniformND_classname

	def UniformND_version() -> "unsigned int":
	return _npstat.UniformND_version()
	UniformND_version = _npstat.UniformND_version

	def UniformND_read(id: 'ClassId', arg3: 'istream') -> "npstat::UniformND *":
	return _npstat.UniformND_read(id, arg3)
	UniformND_read = _npstat.UniformND_read

	class ScalableSymmetricBetaND(AbsScalableDistributionND):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistributionND]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ScalableSymmetricBetaND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistributionND]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ScalableSymmetricBetaND, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double const ', scale: 'double const ', dim: 'unsigned int', n: 'double'):
	this = _npstat.new_ScalableSymmetricBetaND(location, scale, dim, n)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::ScalableSymmetricBetaND *":
	return _npstat.ScalableSymmetricBetaND_clone(self)
	__swig_destroy__ = _npstat.delete_ScalableSymmetricBetaND
	__del__ = lambda self: None

	def mappedByQuantiles(self) -> "bool":
	return _npstat.ScalableSymmetricBetaND_mappedByQuantiles(self)

	def power(self) -> "double":
	return _npstat.ScalableSymmetricBetaND_power(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.ScalableSymmetricBetaND_classId(self)
	if _newclass:
	classname = staticmethod(_npstat.ScalableSymmetricBetaND_classname)
	else:
	classname = _npstat.ScalableSymmetricBetaND_classname
	if _newclass:
	version = staticmethod(_npstat.ScalableSymmetricBetaND_version)
	else:
	version = _npstat.ScalableSymmetricBetaND_version
	ScalableSymmetricBetaND_swigregister = _npstat.ScalableSymmetricBetaND_swigregister
	ScalableSymmetricBetaND_swigregister(ScalableSymmetricBetaND)

	def ScalableSymmetricBetaND_classname() -> "char const *":
	return _npstat.ScalableSymmetricBetaND_classname()
	ScalableSymmetricBetaND_classname = _npstat.ScalableSymmetricBetaND_classname

	def ScalableSymmetricBetaND_version() -> "unsigned int":
	return _npstat.ScalableSymmetricBetaND_version()
	ScalableSymmetricBetaND_version = _npstat.ScalableSymmetricBetaND_version

	class ScalableHuberND(AbsScalableDistributionND):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistributionND]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ScalableHuberND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistributionND]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ScalableHuberND, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double const ', scale: 'double const ', dim: 'unsigned int', tailWeight: 'double'):
	this = _npstat.new_ScalableHuberND(location, scale, dim, tailWeight)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::ScalableHuberND *":
	return _npstat.ScalableHuberND_clone(self)
	__swig_destroy__ = _npstat.delete_ScalableHuberND
	__del__ = lambda self: None

	def mappedByQuantiles(self) -> "bool":
	return _npstat.ScalableHuberND_mappedByQuantiles(self)

	def tailWeight(self) -> "double":
	return _npstat.ScalableHuberND_tailWeight(self)

	def transition(self) -> "double":
	return _npstat.ScalableHuberND_transition(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.ScalableHuberND_classId(self)
	if _newclass:
	classname = staticmethod(_npstat.ScalableHuberND_classname)
	else:
	classname = _npstat.ScalableHuberND_classname
	if _newclass:
	version = staticmethod(_npstat.ScalableHuberND_version)
	else:
	version = _npstat.ScalableHuberND_version
	ScalableHuberND_swigregister = _npstat.ScalableHuberND_swigregister
	ScalableHuberND_swigregister(ScalableHuberND)

	def ScalableHuberND_classname() -> "char const *":
	return _npstat.ScalableHuberND_classname()
	ScalableHuberND_classname = _npstat.ScalableHuberND_classname

	def ScalableHuberND_version() -> "unsigned int":
	return _npstat.ScalableHuberND_version()
	ScalableHuberND_version = _npstat.ScalableHuberND_version

	class ProductSymmetricBetaND(HomogeneousProductSymmetricBeta1D):
	__swig_setmethods__ = {}
	for _s in [HomogeneousProductSymmetricBeta1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ProductSymmetricBetaND, name, value)
	__swig_getmethods__ = {}
	for _s in [HomogeneousProductSymmetricBeta1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ProductSymmetricBetaND, name)
	__repr__ = _swig_repr

	def __init__(self, location: 'double const ', scale: 'double const ', dim: 'unsigned int', power: 'double'):
	this = _npstat.new_ProductSymmetricBetaND(location, scale, dim, power)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::ProductSymmetricBetaND *":
	return _npstat.ProductSymmetricBetaND_clone(self)
	__swig_destroy__ = _npstat.delete_ProductSymmetricBetaND
	__del__ = lambda self: None

	def power(self) -> "double":
	return _npstat.ProductSymmetricBetaND_power(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.ProductSymmetricBetaND_classId(self)
	if _newclass:
	classname = staticmethod(_npstat.ProductSymmetricBetaND_classname)
	else:
	classname = _npstat.ProductSymmetricBetaND_classname
	if _newclass:
	version = staticmethod(_npstat.ProductSymmetricBetaND_version)
	else:
	version = _npstat.ProductSymmetricBetaND_version
	ProductSymmetricBetaND_swigregister = _npstat.ProductSymmetricBetaND_swigregister
	ProductSymmetricBetaND_swigregister(ProductSymmetricBetaND)

	def ProductSymmetricBetaND_classname() -> "char const *":
	return _npstat.ProductSymmetricBetaND_classname()
	ProductSymmetricBetaND_classname = _npstat.ProductSymmetricBetaND_classname

	def ProductSymmetricBetaND_version() -> "unsigned int":
	return _npstat.ProductSymmetricBetaND_version()
	ProductSymmetricBetaND_version = _npstat.ProductSymmetricBetaND_version

	class RadialProfileND(AbsScalableDistributionND):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistributionND]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, RadialProfileND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistributionND]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, RadialProfileND, name)
	__repr__ = _swig_repr

	def clone(self) -> "npstat::RadialProfileND *":
	return _npstat.RadialProfileND_clone(self)
	__swig_destroy__ = _npstat.delete_RadialProfileND
	__del__ = lambda self: None

	def mappedByQuantiles(self) -> "bool":
	return _npstat.RadialProfileND_mappedByQuantiles(self)

	def interpolationDegree(self) -> "unsigned int":
	return _npstat.RadialProfileND_interpolationDegree(self)

	def profileLength(self) -> "unsigned int":
	return _npstat.RadialProfileND_profileLength(self)

	def profileData(self) -> "double const *":
	return _npstat.RadialProfileND_profileData(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.RadialProfileND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.RadialProfileND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.RadialProfileND_classname)
	else:
	classname = _npstat.RadialProfileND_classname
	if _newclass:
	version = staticmethod(_npstat.RadialProfileND_version)
	else:
	version = _npstat.RadialProfileND_version
	if _newclass:
	read = staticmethod(_npstat.RadialProfileND_read)
	else:
	read = _npstat.RadialProfileND_read

	def __init__(self, *args):
	this = _npstat.new_RadialProfileND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	RadialProfileND_swigregister = _npstat.RadialProfileND_swigregister
	RadialProfileND_swigregister(RadialProfileND)

	def RadialProfileND_classname() -> "char const *":
	return _npstat.RadialProfileND_classname()
	RadialProfileND_classname = _npstat.RadialProfileND_classname

	def RadialProfileND_version() -> "unsigned int":
	return _npstat.RadialProfileND_version()
	RadialProfileND_version = _npstat.RadialProfileND_version

	def RadialProfileND_read(id: 'ClassId', arg3: 'istream') -> "npstat::RadialProfileND *":
	return _npstat.RadialProfileND_read(id, arg3)
	RadialProfileND_read = _npstat.RadialProfileND_read

	class BinnedDensityND(AbsScalableDistributionND):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistributionND]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, BinnedDensityND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistributionND]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, BinnedDensityND, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr

	def clone(self) -> "npstat::BinnedDensityND *":
	return _npstat.BinnedDensityND_clone(self)
	__swig_destroy__ = _npstat.delete_BinnedDensityND
	__del__ = lambda self: None

	def mappedByQuantiles(self) -> "bool":
	return _npstat.BinnedDensityND_mappedByQuantiles(self)

	def gridData(self) -> "npstat::ArrayND< double > const &":
	return _npstat.BinnedDensityND_gridData(self)

	def interpolationDegree(self) -> "unsigned int":
	return _npstat.BinnedDensityND_interpolationDegree(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.BinnedDensityND_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.BinnedDensityND_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.BinnedDensityND_classname)
	else:
	classname = _npstat.BinnedDensityND_classname
	if _newclass:
	version = staticmethod(_npstat.BinnedDensityND_version)
	else:
	version = _npstat.BinnedDensityND_version
	if _newclass:
	read = staticmethod(_npstat.BinnedDensityND_read)
	else:
	read = _npstat.BinnedDensityND_read
	BinnedDensityND_swigregister = _npstat.BinnedDensityND_swigregister
	BinnedDensityND_swigregister(BinnedDensityND)

	def BinnedDensityND_classname() -> "char const *":
	return _npstat.BinnedDensityND_classname()
	BinnedDensityND_classname = _npstat.BinnedDensityND_classname

	def BinnedDensityND_version() -> "unsigned int":
	return _npstat.BinnedDensityND_version()
	BinnedDensityND_version = _npstat.BinnedDensityND_version

	def BinnedDensityND_read(id: 'ClassId', arg3: 'istream') -> "npstat::BinnedDensityND *":
	return _npstat.BinnedDensityND_read(id, arg3)
	BinnedDensityND_read = _npstat.BinnedDensityND_read


	def histoCovariance(*args) -> "npstat::Matrix< double,16U >":
	return _npstat.histoCovariance(*args)
	histoCovariance = _npstat.histoCovariance

	def histoMean(*args) -> "std::vector< double,std::allocator< double > >":
	return _npstat.histoMean(*args)
	histoMean = _npstat.histoMean

	def histoQuantiles(*args) -> "std::vector< double,std::allocator< double > >":
	return _npstat.histoQuantiles(*args)
	histoQuantiles = _npstat.histoQuantiles

	def histoDensity1D(args) -> "npstat::BinnedDensity1D ":
	return _npstat.histoDensity1D(*args)
	histoDensity1D = _npstat.histoDensity1D

	def histoDensityND(args) -> "npstat::BinnedDensityND ":
	return _npstat.histoDensityND(*args)
	histoDensityND = _npstat.histoDensityND
	class TruncatedDistribution1D(AbsDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, TruncatedDistribution1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, TruncatedDistribution1D, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_TruncatedDistribution1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::TruncatedDistribution1D *":
	return _npstat.TruncatedDistribution1D_clone(self)
	__swig_destroy__ = _npstat.delete_TruncatedDistribution1D
	__del__ = lambda self: None

	def density(self, x: 'double') -> "double":
	return _npstat.TruncatedDistribution1D_density(self, x)

	def cdf(self, x: 'double') -> "double":
	return _npstat.TruncatedDistribution1D_cdf(self, x)

	def exceedance(self, x: 'double') -> "double":
	return _npstat.TruncatedDistribution1D_exceedance(self, x)

	def quantile(self, x: 'double') -> "double":
	return _npstat.TruncatedDistribution1D_quantile(self, x)

	def classId(self) -> "gs::ClassId":
	return _npstat.TruncatedDistribution1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.TruncatedDistribution1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.TruncatedDistribution1D_classname)
	else:
	classname = _npstat.TruncatedDistribution1D_classname
	if _newclass:
	version = staticmethod(_npstat.TruncatedDistribution1D_version)
	else:
	version = _npstat.TruncatedDistribution1D_version
	if _newclass:
	read = staticmethod(_npstat.TruncatedDistribution1D_read)
	else:
	read = _npstat.TruncatedDistribution1D_read
	TruncatedDistribution1D_swigregister = _npstat.TruncatedDistribution1D_swigregister
	TruncatedDistribution1D_swigregister(TruncatedDistribution1D)

	def TruncatedDistribution1D_classname() -> "char const *":
	return _npstat.TruncatedDistribution1D_classname()
	TruncatedDistribution1D_classname = _npstat.TruncatedDistribution1D_classname

	def TruncatedDistribution1D_version() -> "unsigned int":
	return _npstat.TruncatedDistribution1D_version()
	TruncatedDistribution1D_version = _npstat.TruncatedDistribution1D_version

	def TruncatedDistribution1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::TruncatedDistribution1D *":
	return _npstat.TruncatedDistribution1D_read(id, arg3)
	TruncatedDistribution1D_read = _npstat.TruncatedDistribution1D_read

	class UCharInMemoryNtuple(UCharAbsNtuple):
	__swig_setmethods__ = {}
	for _s in [UCharAbsNtuple]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharInMemoryNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [UCharAbsNtuple]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UCharInMemoryNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, colNames: 'StringVector', ntTitle: 'char const *'=None):
	this = _npstat.new_UCharInMemoryNtuple(colNames, ntTitle)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UCharInMemoryNtuple
	__del__ = lambda self: None

	def nRows(self) -> "unsigned long":
	return _npstat.UCharInMemoryNtuple_nRows(self)

	def fill(self, *args) -> "void":
	return _npstat.UCharInMemoryNtuple_fill(self, *args)

	def __call__(self, r: 'unsigned long const', c: 'unsigned long const') -> "unsigned char":
	return _npstat.UCharInMemoryNtuple___call__(self, r, c)

	def at(self, r: 'unsigned long const', c: 'unsigned long const') -> "unsigned char":
	return _npstat.UCharInMemoryNtuple_at(self, r, c)

	def clear(self) -> "void":
	return _npstat.UCharInMemoryNtuple_clear(self)

	def rowContents(self, row: 'unsigned long', buf: 'unsigned char *', lenBuf: 'unsigned long') -> "void":
	return _npstat.UCharInMemoryNtuple_rowContents(self, row, buf, lenBuf)

	def columnContents(self, c: 'Column', buf: 'unsigned char *', lenBuf: 'unsigned long') -> "void":
	return _npstat.UCharInMemoryNtuple_columnContents(self, c, buf, lenBuf)

	def classId(self) -> "gs::ClassId":
	return _npstat.UCharInMemoryNtuple_classId(self)

	def write(self, arg2: 'ostream') -> "bool":
	return _npstat.UCharInMemoryNtuple_write(self, arg2)
	if _newclass:
	classname = staticmethod(_npstat.UCharInMemoryNtuple_classname)
	else:
	classname = _npstat.UCharInMemoryNtuple_classname
	if _newclass:
	version = staticmethod(_npstat.UCharInMemoryNtuple_version)
	else:
	version = _npstat.UCharInMemoryNtuple_version
	if _newclass:
	read = staticmethod(_npstat.UCharInMemoryNtuple_read)
	else:
	read = _npstat.UCharInMemoryNtuple_read
	UCharInMemoryNtuple_swigregister = _npstat.UCharInMemoryNtuple_swigregister
	UCharInMemoryNtuple_swigregister(UCharInMemoryNtuple)

	def UCharInMemoryNtuple_classname() -> "char const *":
	return _npstat.UCharInMemoryNtuple_classname()
	UCharInMemoryNtuple_classname = _npstat.UCharInMemoryNtuple_classname

	def UCharInMemoryNtuple_version() -> "unsigned int":
	return _npstat.UCharInMemoryNtuple_version()
	UCharInMemoryNtuple_version = _npstat.UCharInMemoryNtuple_version

	def UCharInMemoryNtuple_read(id: 'ClassId', arg3: 'istream') -> "npstat::InMemoryNtuple< unsigned char > *":
	return _npstat.UCharInMemoryNtuple_read(id, arg3)
	UCharInMemoryNtuple_read = _npstat.UCharInMemoryNtuple_read

	class ArchiveRecord_UCharInMemoryNtuple(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_UCharInMemoryNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_UCharInMemoryNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'UCharInMemoryNtuple', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_UCharInMemoryNtuple(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_UCharInMemoryNtuple
	__del__ = lambda self: None
	ArchiveRecord_UCharInMemoryNtuple_swigregister = _npstat.ArchiveRecord_UCharInMemoryNtuple_swigregister
	ArchiveRecord_UCharInMemoryNtuple_swigregister(ArchiveRecord_UCharInMemoryNtuple)

	class Ref_UCharInMemoryNtuple(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_UCharInMemoryNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_UCharInMemoryNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_UCharInMemoryNtuple(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'UCharInMemoryNtuple') -> "void":
	return _npstat.Ref_UCharInMemoryNtuple_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::InMemoryNtuple< unsigned char > *":
	return _npstat.Ref_UCharInMemoryNtuple_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::InMemoryNtuple< unsigned char >":
	return _npstat.Ref_UCharInMemoryNtuple_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_UCharInMemoryNtuple
	__del__ = lambda self: None
	Ref_UCharInMemoryNtuple_swigregister = _npstat.Ref_UCharInMemoryNtuple_swigregister
	Ref_UCharInMemoryNtuple_swigregister(Ref_UCharInMemoryNtuple)

	class IntInMemoryNtuple(IntAbsNtuple):
	__swig_setmethods__ = {}
	for _s in [IntAbsNtuple]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntInMemoryNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [IntAbsNtuple]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, IntInMemoryNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, colNames: 'StringVector', ntTitle: 'char const *'=None):
	this = _npstat.new_IntInMemoryNtuple(colNames, ntTitle)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_IntInMemoryNtuple
	__del__ = lambda self: None

	def nRows(self) -> "unsigned long":
	return _npstat.IntInMemoryNtuple_nRows(self)

	def fill(self, *args) -> "void":
	return _npstat.IntInMemoryNtuple_fill(self, *args)

	def __call__(self, r: 'unsigned long const', c: 'unsigned long const') -> "int":
	return _npstat.IntInMemoryNtuple___call__(self, r, c)

	def at(self, r: 'unsigned long const', c: 'unsigned long const') -> "int":
	return _npstat.IntInMemoryNtuple_at(self, r, c)

	def clear(self) -> "void":
	return _npstat.IntInMemoryNtuple_clear(self)

	def rowContents(self, row: 'unsigned long', buf: 'int *', lenBuf: 'unsigned long') -> "void":
	return _npstat.IntInMemoryNtuple_rowContents(self, row, buf, lenBuf)

	def columnContents(self, c: 'Column', buf: 'int *', lenBuf: 'unsigned long') -> "void":
	return _npstat.IntInMemoryNtuple_columnContents(self, c, buf, lenBuf)

	def classId(self) -> "gs::ClassId":
	return _npstat.IntInMemoryNtuple_classId(self)

	def write(self, arg2: 'ostream') -> "bool":
	return _npstat.IntInMemoryNtuple_write(self, arg2)
	if _newclass:
	classname = staticmethod(_npstat.IntInMemoryNtuple_classname)
	else:
	classname = _npstat.IntInMemoryNtuple_classname
	if _newclass:
	version = staticmethod(_npstat.IntInMemoryNtuple_version)
	else:
	version = _npstat.IntInMemoryNtuple_version
	if _newclass:
	read = staticmethod(_npstat.IntInMemoryNtuple_read)
	else:
	read = _npstat.IntInMemoryNtuple_read
	IntInMemoryNtuple_swigregister = _npstat.IntInMemoryNtuple_swigregister
	IntInMemoryNtuple_swigregister(IntInMemoryNtuple)

	def IntInMemoryNtuple_classname() -> "char const *":
	return _npstat.IntInMemoryNtuple_classname()
	IntInMemoryNtuple_classname = _npstat.IntInMemoryNtuple_classname

	def IntInMemoryNtuple_version() -> "unsigned int":
	return _npstat.IntInMemoryNtuple_version()
	IntInMemoryNtuple_version = _npstat.IntInMemoryNtuple_version

	def IntInMemoryNtuple_read(id: 'ClassId', arg3: 'istream') -> "npstat::InMemoryNtuple< int > *":
	return _npstat.IntInMemoryNtuple_read(id, arg3)
	IntInMemoryNtuple_read = _npstat.IntInMemoryNtuple_read

	class ArchiveRecord_IntInMemoryNtuple(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_IntInMemoryNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_IntInMemoryNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'IntInMemoryNtuple', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_IntInMemoryNtuple(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_IntInMemoryNtuple
	__del__ = lambda self: None
	ArchiveRecord_IntInMemoryNtuple_swigregister = _npstat.ArchiveRecord_IntInMemoryNtuple_swigregister
	ArchiveRecord_IntInMemoryNtuple_swigregister(ArchiveRecord_IntInMemoryNtuple)

	class Ref_IntInMemoryNtuple(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_IntInMemoryNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_IntInMemoryNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_IntInMemoryNtuple(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'IntInMemoryNtuple') -> "void":
	return _npstat.Ref_IntInMemoryNtuple_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::InMemoryNtuple< int > *":
	return _npstat.Ref_IntInMemoryNtuple_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::InMemoryNtuple< int >":
	return _npstat.Ref_IntInMemoryNtuple_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_IntInMemoryNtuple
	__del__ = lambda self: None
	Ref_IntInMemoryNtuple_swigregister = _npstat.Ref_IntInMemoryNtuple_swigregister
	Ref_IntInMemoryNtuple_swigregister(Ref_IntInMemoryNtuple)

	class LLongInMemoryNtuple(LLongAbsNtuple):
	__swig_setmethods__ = {}
	for _s in [LLongAbsNtuple]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongInMemoryNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [LLongAbsNtuple]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LLongInMemoryNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, colNames: 'StringVector', ntTitle: 'char const *'=None):
	this = _npstat.new_LLongInMemoryNtuple(colNames, ntTitle)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_LLongInMemoryNtuple
	__del__ = lambda self: None

	def nRows(self) -> "unsigned long":
	return _npstat.LLongInMemoryNtuple_nRows(self)

	def fill(self, *args) -> "void":
	return _npstat.LLongInMemoryNtuple_fill(self, *args)

	def __call__(self, r: 'unsigned long const', c: 'unsigned long const') -> "long long":
	return _npstat.LLongInMemoryNtuple___call__(self, r, c)

	def at(self, r: 'unsigned long const', c: 'unsigned long const') -> "long long":
	return _npstat.LLongInMemoryNtuple_at(self, r, c)

	def clear(self) -> "void":
	return _npstat.LLongInMemoryNtuple_clear(self)

	def rowContents(self, row: 'unsigned long', buf: 'long long *', lenBuf: 'unsigned long') -> "void":
	return _npstat.LLongInMemoryNtuple_rowContents(self, row, buf, lenBuf)

	def columnContents(self, c: 'Column', buf: 'long long *', lenBuf: 'unsigned long') -> "void":
	return _npstat.LLongInMemoryNtuple_columnContents(self, c, buf, lenBuf)

	def classId(self) -> "gs::ClassId":
	return _npstat.LLongInMemoryNtuple_classId(self)

	def write(self, arg2: 'ostream') -> "bool":
	return _npstat.LLongInMemoryNtuple_write(self, arg2)
	if _newclass:
	classname = staticmethod(_npstat.LLongInMemoryNtuple_classname)
	else:
	classname = _npstat.LLongInMemoryNtuple_classname
	if _newclass:
	version = staticmethod(_npstat.LLongInMemoryNtuple_version)
	else:
	version = _npstat.LLongInMemoryNtuple_version
	if _newclass:
	read = staticmethod(_npstat.LLongInMemoryNtuple_read)
	else:
	read = _npstat.LLongInMemoryNtuple_read
	LLongInMemoryNtuple_swigregister = _npstat.LLongInMemoryNtuple_swigregister
	LLongInMemoryNtuple_swigregister(LLongInMemoryNtuple)

	def LLongInMemoryNtuple_classname() -> "char const *":
	return _npstat.LLongInMemoryNtuple_classname()
	LLongInMemoryNtuple_classname = _npstat.LLongInMemoryNtuple_classname

	def LLongInMemoryNtuple_version() -> "unsigned int":
	return _npstat.LLongInMemoryNtuple_version()
	LLongInMemoryNtuple_version = _npstat.LLongInMemoryNtuple_version

	def LLongInMemoryNtuple_read(id: 'ClassId', arg3: 'istream') -> "npstat::InMemoryNtuple< long long > *":
	return _npstat.LLongInMemoryNtuple_read(id, arg3)
	LLongInMemoryNtuple_read = _npstat.LLongInMemoryNtuple_read

	class ArchiveRecord_LLongInMemoryNtuple(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_LLongInMemoryNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_LLongInMemoryNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'LLongInMemoryNtuple', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_LLongInMemoryNtuple(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_LLongInMemoryNtuple
	__del__ = lambda self: None
	ArchiveRecord_LLongInMemoryNtuple_swigregister = _npstat.ArchiveRecord_LLongInMemoryNtuple_swigregister
	ArchiveRecord_LLongInMemoryNtuple_swigregister(ArchiveRecord_LLongInMemoryNtuple)

	class Ref_LLongInMemoryNtuple(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_LLongInMemoryNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_LLongInMemoryNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_LLongInMemoryNtuple(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'LLongInMemoryNtuple') -> "void":
	return _npstat.Ref_LLongInMemoryNtuple_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::InMemoryNtuple< long long > *":
	return _npstat.Ref_LLongInMemoryNtuple_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::InMemoryNtuple< long long >":
	return _npstat.Ref_LLongInMemoryNtuple_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_LLongInMemoryNtuple
	__del__ = lambda self: None
	Ref_LLongInMemoryNtuple_swigregister = _npstat.Ref_LLongInMemoryNtuple_swigregister
	Ref_LLongInMemoryNtuple_swigregister(Ref_LLongInMemoryNtuple)

	class FloatInMemoryNtuple(FloatAbsNtuple):
	__swig_setmethods__ = {}
	for _s in [FloatAbsNtuple]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatInMemoryNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [FloatAbsNtuple]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatInMemoryNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, colNames: 'StringVector', ntTitle: 'char const *'=None):
	this = _npstat.new_FloatInMemoryNtuple(colNames, ntTitle)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatInMemoryNtuple
	__del__ = lambda self: None

	def nRows(self) -> "unsigned long":
	return _npstat.FloatInMemoryNtuple_nRows(self)

	def fill(self, *args) -> "void":
	return _npstat.FloatInMemoryNtuple_fill(self, *args)

	def __call__(self, r: 'unsigned long const', c: 'unsigned long const') -> "float":
	return _npstat.FloatInMemoryNtuple___call__(self, r, c)

	def at(self, r: 'unsigned long const', c: 'unsigned long const') -> "float":
	return _npstat.FloatInMemoryNtuple_at(self, r, c)

	def clear(self) -> "void":
	return _npstat.FloatInMemoryNtuple_clear(self)

	def rowContents(self, row: 'unsigned long', buf: 'float *', lenBuf: 'unsigned long') -> "void":
	return _npstat.FloatInMemoryNtuple_rowContents(self, row, buf, lenBuf)

	def columnContents(self, c: 'Column', buf: 'float *', lenBuf: 'unsigned long') -> "void":
	return _npstat.FloatInMemoryNtuple_columnContents(self, c, buf, lenBuf)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatInMemoryNtuple_classId(self)

	def write(self, arg2: 'ostream') -> "bool":
	return _npstat.FloatInMemoryNtuple_write(self, arg2)
	if _newclass:
	classname = staticmethod(_npstat.FloatInMemoryNtuple_classname)
	else:
	classname = _npstat.FloatInMemoryNtuple_classname
	if _newclass:
	version = staticmethod(_npstat.FloatInMemoryNtuple_version)
	else:
	version = _npstat.FloatInMemoryNtuple_version
	if _newclass:
	read = staticmethod(_npstat.FloatInMemoryNtuple_read)
	else:
	read = _npstat.FloatInMemoryNtuple_read
	FloatInMemoryNtuple_swigregister = _npstat.FloatInMemoryNtuple_swigregister
	FloatInMemoryNtuple_swigregister(FloatInMemoryNtuple)

	def FloatInMemoryNtuple_classname() -> "char const *":
	return _npstat.FloatInMemoryNtuple_classname()
	FloatInMemoryNtuple_classname = _npstat.FloatInMemoryNtuple_classname

	def FloatInMemoryNtuple_version() -> "unsigned int":
	return _npstat.FloatInMemoryNtuple_version()
	FloatInMemoryNtuple_version = _npstat.FloatInMemoryNtuple_version

	def FloatInMemoryNtuple_read(id: 'ClassId', arg3: 'istream') -> "npstat::InMemoryNtuple< float > *":
	return _npstat.FloatInMemoryNtuple_read(id, arg3)
	FloatInMemoryNtuple_read = _npstat.FloatInMemoryNtuple_read

	class ArchiveRecord_FloatInMemoryNtuple(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_FloatInMemoryNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_FloatInMemoryNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'FloatInMemoryNtuple', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_FloatInMemoryNtuple(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_FloatInMemoryNtuple
	__del__ = lambda self: None
	ArchiveRecord_FloatInMemoryNtuple_swigregister = _npstat.ArchiveRecord_FloatInMemoryNtuple_swigregister
	ArchiveRecord_FloatInMemoryNtuple_swigregister(ArchiveRecord_FloatInMemoryNtuple)

	class Ref_FloatInMemoryNtuple(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_FloatInMemoryNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_FloatInMemoryNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_FloatInMemoryNtuple(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'FloatInMemoryNtuple') -> "void":
	return _npstat.Ref_FloatInMemoryNtuple_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::InMemoryNtuple< float > *":
	return _npstat.Ref_FloatInMemoryNtuple_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::InMemoryNtuple< float >":
	return _npstat.Ref_FloatInMemoryNtuple_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_FloatInMemoryNtuple
	__del__ = lambda self: None
	Ref_FloatInMemoryNtuple_swigregister = _npstat.Ref_FloatInMemoryNtuple_swigregister
	Ref_FloatInMemoryNtuple_swigregister(Ref_FloatInMemoryNtuple)

	class DoubleInMemoryNtuple(DoubleAbsNtuple):
	__swig_setmethods__ = {}
	for _s in [DoubleAbsNtuple]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleInMemoryNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleAbsNtuple]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleInMemoryNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, colNames: 'StringVector', ntTitle: 'char const *'=None):
	this = _npstat.new_DoubleInMemoryNtuple(colNames, ntTitle)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleInMemoryNtuple
	__del__ = lambda self: None

	def nRows(self) -> "unsigned long":
	return _npstat.DoubleInMemoryNtuple_nRows(self)

	def fill(self, *args) -> "void":
	return _npstat.DoubleInMemoryNtuple_fill(self, *args)

	def __call__(self, r: 'unsigned long const', c: 'unsigned long const') -> "double":
	return _npstat.DoubleInMemoryNtuple___call__(self, r, c)

	def at(self, r: 'unsigned long const', c: 'unsigned long const') -> "double":
	return _npstat.DoubleInMemoryNtuple_at(self, r, c)

	def clear(self) -> "void":
	return _npstat.DoubleInMemoryNtuple_clear(self)

	def rowContents(self, row: 'unsigned long', buf: 'double *', lenBuf: 'unsigned long') -> "void":
	return _npstat.DoubleInMemoryNtuple_rowContents(self, row, buf, lenBuf)

	def columnContents(self, c: 'Column', buf: 'double *', lenBuf: 'unsigned long') -> "void":
	return _npstat.DoubleInMemoryNtuple_columnContents(self, c, buf, lenBuf)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleInMemoryNtuple_classId(self)

	def write(self, arg2: 'ostream') -> "bool":
	return _npstat.DoubleInMemoryNtuple_write(self, arg2)
	if _newclass:
	classname = staticmethod(_npstat.DoubleInMemoryNtuple_classname)
	else:
	classname = _npstat.DoubleInMemoryNtuple_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleInMemoryNtuple_version)
	else:
	version = _npstat.DoubleInMemoryNtuple_version
	if _newclass:
	read = staticmethod(_npstat.DoubleInMemoryNtuple_read)
	else:
	read = _npstat.DoubleInMemoryNtuple_read
	DoubleInMemoryNtuple_swigregister = _npstat.DoubleInMemoryNtuple_swigregister
	DoubleInMemoryNtuple_swigregister(DoubleInMemoryNtuple)

	def DoubleInMemoryNtuple_classname() -> "char const *":
	return _npstat.DoubleInMemoryNtuple_classname()
	DoubleInMemoryNtuple_classname = _npstat.DoubleInMemoryNtuple_classname

	def DoubleInMemoryNtuple_version() -> "unsigned int":
	return _npstat.DoubleInMemoryNtuple_version()
	DoubleInMemoryNtuple_version = _npstat.DoubleInMemoryNtuple_version

	def DoubleInMemoryNtuple_read(id: 'ClassId', arg3: 'istream') -> "npstat::InMemoryNtuple< double > *":
	return _npstat.DoubleInMemoryNtuple_read(id, arg3)
	DoubleInMemoryNtuple_read = _npstat.DoubleInMemoryNtuple_read

	class ArchiveRecord_DoubleInMemoryNtuple(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DoubleInMemoryNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DoubleInMemoryNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DoubleInMemoryNtuple', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DoubleInMemoryNtuple(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DoubleInMemoryNtuple
	__del__ = lambda self: None
	ArchiveRecord_DoubleInMemoryNtuple_swigregister = _npstat.ArchiveRecord_DoubleInMemoryNtuple_swigregister
	ArchiveRecord_DoubleInMemoryNtuple_swigregister(ArchiveRecord_DoubleInMemoryNtuple)

	class Ref_DoubleInMemoryNtuple(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DoubleInMemoryNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DoubleInMemoryNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DoubleInMemoryNtuple(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DoubleInMemoryNtuple') -> "void":
	return _npstat.Ref_DoubleInMemoryNtuple_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::InMemoryNtuple< double > *":
	return _npstat.Ref_DoubleInMemoryNtuple_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::InMemoryNtuple< double >":
	return _npstat.Ref_DoubleInMemoryNtuple_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DoubleInMemoryNtuple
	__del__ = lambda self: None
	Ref_DoubleInMemoryNtuple_swigregister = _npstat.Ref_DoubleInMemoryNtuple_swigregister
	Ref_DoubleInMemoryNtuple_swigregister(Ref_DoubleInMemoryNtuple)

	class QuantileTable1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, QuantileTable1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, QuantileTable1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr

	def clone(self) -> "npstat::QuantileTable1D *":
	return _npstat.QuantileTable1D_clone(self)
	__swig_destroy__ = _npstat.delete_QuantileTable1D
	__del__ = lambda self: None

	def classId(self) -> "gs::ClassId":
	return _npstat.QuantileTable1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.QuantileTable1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.QuantileTable1D_classname)
	else:
	classname = _npstat.QuantileTable1D_classname
	if _newclass:
	version = staticmethod(_npstat.QuantileTable1D_version)
	else:
	version = _npstat.QuantileTable1D_version
	if _newclass:
	read = staticmethod(_npstat.QuantileTable1D_read)
	else:
	read = _npstat.QuantileTable1D_read
	QuantileTable1D_swigregister = _npstat.QuantileTable1D_swigregister
	QuantileTable1D_swigregister(QuantileTable1D)

	def QuantileTable1D_classname() -> "char const *":
	return _npstat.QuantileTable1D_classname()
	QuantileTable1D_classname = _npstat.QuantileTable1D_classname

	def QuantileTable1D_version() -> "unsigned int":
	return _npstat.QuantileTable1D_version()
	QuantileTable1D_version = _npstat.QuantileTable1D_version

	def QuantileTable1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::QuantileTable1D *":
	return _npstat.QuantileTable1D_read(id, arg3)
	QuantileTable1D_read = _npstat.QuantileTable1D_read

	class BoundaryHandling(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, BoundaryHandling, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, BoundaryHandling, name)
	__repr__ = _swig_repr
	BM_MAXPARAMS = _npstat.BoundaryHandling_BM_MAXPARAMS

	def __init__(self, *args):
	this = _npstat.new_BoundaryHandling(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def methodName(self) -> "char const *":
	return _npstat.BoundaryHandling_methodName(self)

	def parameters(self) -> "double const *":
	return _npstat.BoundaryHandling_parameters(self)

	def nParameters(self) -> "unsigned int":
	return _npstat.BoundaryHandling_nParameters(self)

	def methodId(self) -> "unsigned int":
	return _npstat.BoundaryHandling_methodId(self)

	def __eq__(self, r: 'BoundaryHandling') -> "bool":
	return _npstat.BoundaryHandling___eq__(self, r)

	def __ne__(self, r: 'BoundaryHandling') -> "bool":
	return _npstat.BoundaryHandling___ne__(self, r)

	def __lt__(self, r: 'BoundaryHandling') -> "bool":
	return _npstat.BoundaryHandling___lt__(self, r)

	def __gt__(self, r: 'BoundaryHandling') -> "bool":
	return _npstat.BoundaryHandling___gt__(self, r)
	if _newclass:
	isValidMethodName = staticmethod(_npstat.BoundaryHandling_isValidMethodName)
	else:
	isValidMethodName = _npstat.BoundaryHandling_isValidMethodName
	if _newclass:
	validMethodNames = staticmethod(_npstat.BoundaryHandling_validMethodNames)
	else:
	validMethodNames = _npstat.BoundaryHandling_validMethodNames
	if _newclass:
	isParameterFree = staticmethod(_npstat.BoundaryHandling_isParameterFree)
	else:
	isParameterFree = _npstat.BoundaryHandling_isParameterFree
	if _newclass:
	parameterFreeNames = staticmethod(_npstat.BoundaryHandling_parameterFreeNames)
	else:
	parameterFreeNames = _npstat.BoundaryHandling_parameterFreeNames
	if _newclass:
	expectedNParameters = staticmethod(_npstat.BoundaryHandling_expectedNParameters)
	else:
	expectedNParameters = _npstat.BoundaryHandling_expectedNParameters

	def classId(self) -> "gs::ClassId":
	return _npstat.BoundaryHandling_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.BoundaryHandling_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.BoundaryHandling_classname)
	else:
	classname = _npstat.BoundaryHandling_classname
	if _newclass:
	version = staticmethod(_npstat.BoundaryHandling_version)
	else:
	version = _npstat.BoundaryHandling_version
	if _newclass:
	restore = staticmethod(_npstat.BoundaryHandling_restore)
	else:
	restore = _npstat.BoundaryHandling_restore
	__swig_destroy__ = _npstat.delete_BoundaryHandling
	__del__ = lambda self: None
	BoundaryHandling_swigregister = _npstat.BoundaryHandling_swigregister
	BoundaryHandling_swigregister(BoundaryHandling)

	def BoundaryHandling_isValidMethodName(name: 'char const *') -> "bool":
	return _npstat.BoundaryHandling_isValidMethodName(name)
	BoundaryHandling_isValidMethodName = _npstat.BoundaryHandling_isValidMethodName

	def BoundaryHandling_validMethodNames() -> "std::string":
	return _npstat.BoundaryHandling_validMethodNames()
	BoundaryHandling_validMethodNames = _npstat.BoundaryHandling_validMethodNames

	def BoundaryHandling_isParameterFree(name: 'char const *') -> "bool":
	return _npstat.BoundaryHandling_isParameterFree(name)
	BoundaryHandling_isParameterFree = _npstat.BoundaryHandling_isParameterFree

	def BoundaryHandling_parameterFreeNames() -> "std::string":
	return _npstat.BoundaryHandling_parameterFreeNames()
	BoundaryHandling_parameterFreeNames = _npstat.BoundaryHandling_parameterFreeNames

	def BoundaryHandling_expectedNParameters(name: 'char const *') -> "unsigned int":
	return _npstat.BoundaryHandling_expectedNParameters(name)
	BoundaryHandling_expectedNParameters = _npstat.BoundaryHandling_expectedNParameters

	def BoundaryHandling_classname() -> "char const *":
	return _npstat.BoundaryHandling_classname()
	BoundaryHandling_classname = _npstat.BoundaryHandling_classname

	def BoundaryHandling_version() -> "unsigned int":
	return _npstat.BoundaryHandling_version()
	BoundaryHandling_version = _npstat.BoundaryHandling_version

	def BoundaryHandling_restore(id: 'ClassId', arg3: 'istream', ptr: 'BoundaryHandling') -> "void":
	return _npstat.BoundaryHandling_restore(id, arg3, ptr)
	BoundaryHandling_restore = _npstat.BoundaryHandling_restore


	def lorpeMise1D(m: 'int', lorpeDegree: 'double', bandwidth: 'double', sampleSize: 'double', nintervals: 'unsigned int', xmin: 'double', xmax: 'double', distro: 'AbsDistribution1D', bm: 'BoundaryHandling', oversample: 'unsigned int'=10, ISB: 'double '=None, variance: 'double '=None) -> "double":
	return _npstat.lorpeMise1D(m, lorpeDegree, bandwidth, sampleSize, nintervals, xmin, xmax, distro, bm, oversample, ISB, variance)
	lorpeMise1D = _npstat.lorpeMise1D
	class StatAccumulatorPair(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, StatAccumulatorPair, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, StatAccumulatorPair, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_StatAccumulatorPair()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def first(self) -> "npstat::StatAccumulator const &":
	return _npstat.StatAccumulatorPair_first(self)

	def second(self) -> "npstat::StatAccumulator const &":
	return _npstat.StatAccumulatorPair_second(self)

	def crossSumsq(self) -> "long double":
	return _npstat.StatAccumulatorPair_crossSumsq(self)

	def count(self) -> "unsigned long":
	return _npstat.StatAccumulatorPair_count(self)

	def cov(self) -> "double":
	return _npstat.StatAccumulatorPair_cov(self)

	def corr(self) -> "double":
	return _npstat.StatAccumulatorPair_corr(self)

	def accumulate(self, *args) -> "void":
	return _npstat.StatAccumulatorPair_accumulate(self, *args)

	def reset(self) -> "void":
	return _npstat.StatAccumulatorPair_reset(self)

	def __iadd__(self, *args) -> "npstat::StatAccumulatorPair &":
	return _npstat.StatAccumulatorPair___iadd__(self, *args)

	def __eq__(self, r: 'StatAccumulatorPair') -> "bool":
	return _npstat.StatAccumulatorPair___eq__(self, r)

	def __ne__(self, r: 'StatAccumulatorPair') -> "bool":
	return _npstat.StatAccumulatorPair___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.StatAccumulatorPair_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.StatAccumulatorPair_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.StatAccumulatorPair_classname)
	else:
	classname = _npstat.StatAccumulatorPair_classname
	if _newclass:
	version = staticmethod(_npstat.StatAccumulatorPair_version)
	else:
	version = _npstat.StatAccumulatorPair_version
	if _newclass:
	restore = staticmethod(_npstat.StatAccumulatorPair_restore)
	else:
	restore = _npstat.StatAccumulatorPair_restore
	__swig_destroy__ = _npstat.delete_StatAccumulatorPair
	__del__ = lambda self: None
	StatAccumulatorPair_swigregister = _npstat.StatAccumulatorPair_swigregister
	StatAccumulatorPair_swigregister(StatAccumulatorPair)

	def StatAccumulatorPair_classname() -> "char const *":
	return _npstat.StatAccumulatorPair_classname()
	StatAccumulatorPair_classname = _npstat.StatAccumulatorPair_classname

	def StatAccumulatorPair_version() -> "unsigned int":
	return _npstat.StatAccumulatorPair_version()
	StatAccumulatorPair_version = _npstat.StatAccumulatorPair_version

	def StatAccumulatorPair_restore(id: 'ClassId', arg3: 'istream', acc: 'StatAccumulatorPair') -> "void":
	return _npstat.StatAccumulatorPair_restore(id, arg3, acc)
	StatAccumulatorPair_restore = _npstat.StatAccumulatorPair_restore

	class StorableMultivariateFunctor(AbsMultivariateFunctor):
	__swig_setmethods__ = {}
	for _s in [AbsMultivariateFunctor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, StorableMultivariateFunctor, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsMultivariateFunctor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, StorableMultivariateFunctor, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_StorableMultivariateFunctor
	__del__ = lambda self: None

	def description(self) -> "std::string const &":
	return _npstat.StorableMultivariateFunctor_description(self)

	def setDescription(self, newDescription: 'string') -> "void":
	return _npstat.StorableMultivariateFunctor_setDescription(self, newDescription)

	def validateDescription(self, description: 'string') -> "void":
	return _npstat.StorableMultivariateFunctor_validateDescription(self, description)

	def __eq__(self, r: 'StorableMultivariateFunctor') -> "bool":
	return _npstat.StorableMultivariateFunctor___eq__(self, r)

	def __ne__(self, r: 'StorableMultivariateFunctor') -> "bool":
	return _npstat.StorableMultivariateFunctor___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.StorableMultivariateFunctor_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.StorableMultivariateFunctor_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.StorableMultivariateFunctor_classname)
	else:
	classname = _npstat.StorableMultivariateFunctor_classname
	if _newclass:
	version = staticmethod(_npstat.StorableMultivariateFunctor_version)
	else:
	version = _npstat.StorableMultivariateFunctor_version
	if _newclass:
	read = staticmethod(_npstat.StorableMultivariateFunctor_read)
	else:
	read = _npstat.StorableMultivariateFunctor_read
	StorableMultivariateFunctor_swigregister = _npstat.StorableMultivariateFunctor_swigregister
	StorableMultivariateFunctor_swigregister(StorableMultivariateFunctor)

	def StorableMultivariateFunctor_classname() -> "char const *":
	return _npstat.StorableMultivariateFunctor_classname()
	StorableMultivariateFunctor_classname = _npstat.StorableMultivariateFunctor_classname

	def StorableMultivariateFunctor_version() -> "unsigned int":
	return _npstat.StorableMultivariateFunctor_version()
	StorableMultivariateFunctor_version = _npstat.StorableMultivariateFunctor_version

	def StorableMultivariateFunctor_read(id: 'ClassId', arg3: 'istream') -> "npstat::StorableMultivariateFunctor *":
	return _npstat.StorableMultivariateFunctor_read(id, arg3)
	StorableMultivariateFunctor_read = _npstat.StorableMultivariateFunctor_read

	class UniformAxis(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UniformAxis, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UniformAxis, name)
	__repr__ = _swig_repr

	def nCoords(self) -> "unsigned int":
	return _npstat.UniformAxis_nCoords(self)

	def min(self) -> "double":
	return _npstat.UniformAxis_min(self)

	def max(self) -> "double":
	return _npstat.UniformAxis_max(self)

	def label(self) -> "std::string const &":
	return _npstat.UniformAxis_label(self)

	def usesLogSpace(self) -> "bool":
	return _npstat.UniformAxis_usesLogSpace(self)

	def getInterval(self, coordinate: 'double') -> "std::pair< unsigned int,double >":
	return _npstat.UniformAxis_getInterval(self, coordinate)

	def linearInterval(self, coordinate: 'double') -> "std::pair< unsigned int,double >":
	return _npstat.UniformAxis_linearInterval(self, coordinate)

	def coords(self) -> "std::vector< double,std::allocator< double > >":
	return _npstat.UniformAxis_coords(self)

	def coordinate(self, i: 'unsigned int') -> "double":
	return _npstat.UniformAxis_coordinate(self, i)

	def length(self) -> "double":
	return _npstat.UniformAxis_length(self)

	def isUniform(self) -> "bool":
	return _npstat.UniformAxis_isUniform(self)

	def nIntervals(self) -> "unsigned int":
	return _npstat.UniformAxis_nIntervals(self)

	def intervalWidth(self, arg2: 'unsigned int') -> "double":
	return _npstat.UniformAxis_intervalWidth(self, arg2)

	def __eq__(self, r: 'UniformAxis') -> "bool":
	return _npstat.UniformAxis___eq__(self, r)

	def __ne__(self, r: 'UniformAxis') -> "bool":
	return _npstat.UniformAxis___ne__(self, r)

	def isClose(self, r: 'UniformAxis', tol: 'double') -> "bool":
	return _npstat.UniformAxis_isClose(self, r, tol)

	def setLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.UniformAxis_setLabel(self, newlabel)

	def classId(self) -> "gs::ClassId":
	return _npstat.UniformAxis_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.UniformAxis_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.UniformAxis_classname)
	else:
	classname = _npstat.UniformAxis_classname
	if _newclass:
	version = staticmethod(_npstat.UniformAxis_version)
	else:
	version = _npstat.UniformAxis_version
	if _newclass:
	read = staticmethod(_npstat.UniformAxis_read)
	else:
	read = _npstat.UniformAxis_read

	def range(self) -> "std::pair< double,double >":
	return _npstat.UniformAxis_range(self)

	def __init__(self, *args):
	this = _npstat.new_UniformAxis(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UniformAxis
	__del__ = lambda self: None
	UniformAxis_swigregister = _npstat.UniformAxis_swigregister
	UniformAxis_swigregister(UniformAxis)

	def UniformAxis_classname() -> "char const *":
	return _npstat.UniformAxis_classname()
	UniformAxis_classname = _npstat.UniformAxis_classname

	def UniformAxis_version() -> "unsigned int":
	return _npstat.UniformAxis_version()
	UniformAxis_version = _npstat.UniformAxis_version

	def UniformAxis_read(id: 'ClassId', arg3: 'istream') -> "npstat::UniformAxis *":
	return _npstat.UniformAxis_read(id, arg3)
	UniformAxis_read = _npstat.UniformAxis_read

	class UniformAxisVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UniformAxisVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UniformAxisVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.UniformAxisVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.UniformAxisVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.UniformAxisVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::UniformAxis >::size_type":
	return _npstat.UniformAxisVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::UniformAxis >::difference_type', j: 'std::vector< npstat::UniformAxis >::difference_type') -> "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > *":
	return _npstat.UniformAxisVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.UniformAxisVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::UniformAxis >::difference_type', j: 'std::vector< npstat::UniformAxis >::difference_type') -> "void":
	return _npstat.UniformAxisVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.UniformAxisVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::UniformAxis >::value_type const &":
	return _npstat.UniformAxisVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.UniformAxisVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::UniformAxis >::value_type":
	return _npstat.UniformAxisVector_pop(self)

	def append(self, x: 'UniformAxis') -> "void":
	return _npstat.UniformAxisVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.UniformAxisVector_empty(self)

	def size(self) -> "std::vector< npstat::UniformAxis >::size_type":
	return _npstat.UniformAxisVector_size(self)

	def swap(self, v: 'UniformAxisVector') -> "void":
	return _npstat.UniformAxisVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::UniformAxis >::iterator":
	return _npstat.UniformAxisVector_begin(self)

	def end(self) -> "std::vector< npstat::UniformAxis >::iterator":
	return _npstat.UniformAxisVector_end(self)

	def rbegin(self) -> "std::vector< npstat::UniformAxis >::reverse_iterator":
	return _npstat.UniformAxisVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::UniformAxis >::reverse_iterator":
	return _npstat.UniformAxisVector_rend(self)

	def clear(self) -> "void":
	return _npstat.UniformAxisVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::UniformAxis >::allocator_type":
	return _npstat.UniformAxisVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.UniformAxisVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::UniformAxis >::iterator":
	return _npstat.UniformAxisVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_UniformAxisVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'UniformAxis') -> "void":
	return _npstat.UniformAxisVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::UniformAxis >::value_type const &":
	return _npstat.UniformAxisVector_front(self)

	def back(self) -> "std::vector< npstat::UniformAxis >::value_type const &":
	return _npstat.UniformAxisVector_back(self)

	def assign(self, n: 'std::vector< npstat::UniformAxis >::size_type', x: 'UniformAxis') -> "void":
	return _npstat.UniformAxisVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.UniformAxisVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.UniformAxisVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::UniformAxis >::size_type') -> "void":
	return _npstat.UniformAxisVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::UniformAxis >::size_type":
	return _npstat.UniformAxisVector_capacity(self)
	__swig_destroy__ = _npstat.delete_UniformAxisVector
	__del__ = lambda self: None
	UniformAxisVector_swigregister = _npstat.UniformAxisVector_swigregister
	UniformAxisVector_swigregister(UniformAxisVector)

	class DualAxis(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DualAxis, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DualAxis, name)
	__repr__ = _swig_repr

	def isUniform(self) -> "bool":
	return _npstat.DualAxis_isUniform(self)

	def nCoords(self) -> "unsigned int":
	return _npstat.DualAxis_nCoords(self)

	def min(self) -> "double":
	return _npstat.DualAxis_min(self)

	def max(self) -> "double":
	return _npstat.DualAxis_max(self)

	def label(self) -> "std::string const &":
	return _npstat.DualAxis_label(self)

	def usesLogSpace(self) -> "bool":
	return _npstat.DualAxis_usesLogSpace(self)

	def getInterval(self, x: 'double const') -> "std::pair< unsigned int,double >":
	return _npstat.DualAxis_getInterval(self, x)

	def linearInterval(self, x: 'double const') -> "std::pair< unsigned int,double >":
	return _npstat.DualAxis_linearInterval(self, x)

	def coordinate(self, i: 'unsigned int const') -> "double":
	return _npstat.DualAxis_coordinate(self, i)

	def length(self) -> "double":
	return _npstat.DualAxis_length(self)

	def nIntervals(self) -> "unsigned int":
	return _npstat.DualAxis_nIntervals(self)

	def intervalWidth(self, i: 'unsigned int const'=0) -> "double":
	return _npstat.DualAxis_intervalWidth(self, i)

	def coords(self) -> "std::vector< double,std::allocator< double > >":
	return _npstat.DualAxis_coords(self)

	def __eq__(self, r: 'DualAxis') -> "bool":
	return _npstat.DualAxis___eq__(self, r)

	def __ne__(self, r: 'DualAxis') -> "bool":
	return _npstat.DualAxis___ne__(self, r)

	def getGridAxis(self) -> "npstat::GridAxis const *":
	return _npstat.DualAxis_getGridAxis(self)

	def getUniformAxis(self) -> "npstat::UniformAxis const *":
	return _npstat.DualAxis_getUniformAxis(self)

	def setLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.DualAxis_setLabel(self, newlabel)

	def classId(self) -> "gs::ClassId":
	return _npstat.DualAxis_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DualAxis_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DualAxis_classname)
	else:
	classname = _npstat.DualAxis_classname
	if _newclass:
	version = staticmethod(_npstat.DualAxis_version)
	else:
	version = _npstat.DualAxis_version
	if _newclass:
	read = staticmethod(_npstat.DualAxis_read)
	else:
	read = _npstat.DualAxis_read

	def range(self) -> "std::pair< double,double >":
	return _npstat.DualAxis_range(self)

	def __init__(self, *args):
	this = _npstat.new_DualAxis(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DualAxis
	__del__ = lambda self: None
	DualAxis_swigregister = _npstat.DualAxis_swigregister
	DualAxis_swigregister(DualAxis)

	def DualAxis_classname() -> "char const *":
	return _npstat.DualAxis_classname()
	DualAxis_classname = _npstat.DualAxis_classname

	def DualAxis_version() -> "unsigned int":
	return _npstat.DualAxis_version()
	DualAxis_version = _npstat.DualAxis_version

	def DualAxis_read(id: 'ClassId', arg3: 'istream') -> "npstat::DualAxis *":
	return _npstat.DualAxis_read(id, arg3)
	DualAxis_read = _npstat.DualAxis_read

	class DualAxisVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DualAxisVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DualAxisVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.DualAxisVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.DualAxisVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.DualAxisVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::DualAxis >::size_type":
	return _npstat.DualAxisVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::DualAxis >::difference_type', j: 'std::vector< npstat::DualAxis >::difference_type') -> "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > *":
	return _npstat.DualAxisVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.DualAxisVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::DualAxis >::difference_type', j: 'std::vector< npstat::DualAxis >::difference_type') -> "void":
	return _npstat.DualAxisVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.DualAxisVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::DualAxis >::value_type const &":
	return _npstat.DualAxisVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.DualAxisVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::DualAxis >::value_type":
	return _npstat.DualAxisVector_pop(self)

	def append(self, x: 'DualAxis') -> "void":
	return _npstat.DualAxisVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.DualAxisVector_empty(self)

	def size(self) -> "std::vector< npstat::DualAxis >::size_type":
	return _npstat.DualAxisVector_size(self)

	def swap(self, v: 'DualAxisVector') -> "void":
	return _npstat.DualAxisVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::DualAxis >::iterator":
	return _npstat.DualAxisVector_begin(self)

	def end(self) -> "std::vector< npstat::DualAxis >::iterator":
	return _npstat.DualAxisVector_end(self)

	def rbegin(self) -> "std::vector< npstat::DualAxis >::reverse_iterator":
	return _npstat.DualAxisVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::DualAxis >::reverse_iterator":
	return _npstat.DualAxisVector_rend(self)

	def clear(self) -> "void":
	return _npstat.DualAxisVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::DualAxis >::allocator_type":
	return _npstat.DualAxisVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.DualAxisVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::DualAxis >::iterator":
	return _npstat.DualAxisVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_DualAxisVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'DualAxis') -> "void":
	return _npstat.DualAxisVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::DualAxis >::value_type const &":
	return _npstat.DualAxisVector_front(self)

	def back(self) -> "std::vector< npstat::DualAxis >::value_type const &":
	return _npstat.DualAxisVector_back(self)

	def assign(self, n: 'std::vector< npstat::DualAxis >::size_type', x: 'DualAxis') -> "void":
	return _npstat.DualAxisVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.DualAxisVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.DualAxisVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::DualAxis >::size_type') -> "void":
	return _npstat.DualAxisVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::DualAxis >::size_type":
	return _npstat.DualAxisVector_capacity(self)
	__swig_destroy__ = _npstat.delete_DualAxisVector
	__del__ = lambda self: None
	DualAxisVector_swigregister = _npstat.DualAxisVector_swigregister
	DualAxisVector_swigregister(DualAxisVector)

	class DoubleLinInterpolatedTableND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleLinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleLinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_DoubleLinInterpolatedTableND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, *args) -> "double":
	return _npstat.DoubleLinInterpolatedTableND___call__(self, *args)

	def dim(self) -> "unsigned int":
	return _npstat.DoubleLinInterpolatedTableND_dim(self)

	def axes(self) -> "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &":
	return _npstat.DoubleLinInterpolatedTableND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::UniformAxis const &":
	return _npstat.DoubleLinInterpolatedTableND_axis(self, i)

	def length(self) -> "unsigned long":
	return _npstat.DoubleLinInterpolatedTableND_length(self)

	def leftInterpolationLinear(self, i: 'unsigned int') -> "bool":
	return _npstat.DoubleLinInterpolatedTableND_leftInterpolationLinear(self, i)

	def rightInterpolationLinear(self, i: 'unsigned int') -> "bool":
	return _npstat.DoubleLinInterpolatedTableND_rightInterpolationLinear(self, i)

	def interpolationType(self) -> "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >":
	return _npstat.DoubleLinInterpolatedTableND_interpolationType(self)

	def functionLabel(self) -> "std::string const &":
	return _npstat.DoubleLinInterpolatedTableND_functionLabel(self)

	def table(self, *args) -> "npstat::ArrayND< double > &":
	return _npstat.DoubleLinInterpolatedTableND_table(self, *args)

	def getCoords(self, linearIndex: 'unsigned long', coords: 'double *', coordsBufferSize: 'unsigned int') -> "void":
	return _npstat.DoubleLinInterpolatedTableND_getCoords(self, linearIndex, coords, coordsBufferSize)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.DoubleLinInterpolatedTableND_isUniformlyBinned(self)

	def isWithinLimits(self, point: 'double const *') -> "bool":
	return _npstat.DoubleLinInterpolatedTableND_isWithinLimits(self, point)

	def setFunctionLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.DoubleLinInterpolatedTableND_setFunctionLabel(self, newlabel)

	def __eq__(self, arg2: 'DoubleLinInterpolatedTableND') -> "bool":
	return _npstat.DoubleLinInterpolatedTableND___eq__(self, arg2)

	def __ne__(self, r: 'DoubleLinInterpolatedTableND') -> "bool":
	return _npstat.DoubleLinInterpolatedTableND___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleLinInterpolatedTableND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleLinInterpolatedTableND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleLinInterpolatedTableND_classname)
	else:
	classname = _npstat.DoubleLinInterpolatedTableND_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleLinInterpolatedTableND_version)
	else:
	version = _npstat.DoubleLinInterpolatedTableND_version
	if _newclass:
	read = staticmethod(_npstat.DoubleLinInterpolatedTableND_read)
	else:
	read = _npstat.DoubleLinInterpolatedTableND_read
	__swig_destroy__ = _npstat.delete_DoubleLinInterpolatedTableND
	__del__ = lambda self: None
	DoubleLinInterpolatedTableND_swigregister = _npstat.DoubleLinInterpolatedTableND_swigregister
	DoubleLinInterpolatedTableND_swigregister(DoubleLinInterpolatedTableND)

	def DoubleLinInterpolatedTableND_classname() -> "char const *":
	return _npstat.DoubleLinInterpolatedTableND_classname()
	DoubleLinInterpolatedTableND_classname = _npstat.DoubleLinInterpolatedTableND_classname

	def DoubleLinInterpolatedTableND_version() -> "unsigned int":
	return _npstat.DoubleLinInterpolatedTableND_version()
	DoubleLinInterpolatedTableND_version = _npstat.DoubleLinInterpolatedTableND_version

	def DoubleLinInterpolatedTableND_read(id: 'ClassId', arg3: 'istream') -> "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *":
	return _npstat.DoubleLinInterpolatedTableND_read(id, arg3)
	DoubleLinInterpolatedTableND_read = _npstat.DoubleLinInterpolatedTableND_read

	class DoubleNULinInterpolatedTableND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleNULinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleNULinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_DoubleNULinInterpolatedTableND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, *args) -> "double":
	return _npstat.DoubleNULinInterpolatedTableND___call__(self, *args)

	def dim(self) -> "unsigned int":
	return _npstat.DoubleNULinInterpolatedTableND_dim(self)

	def axes(self) -> "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &":
	return _npstat.DoubleNULinInterpolatedTableND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::GridAxis const &":
	return _npstat.DoubleNULinInterpolatedTableND_axis(self, i)

	def length(self) -> "unsigned long":
	return _npstat.DoubleNULinInterpolatedTableND_length(self)

	def leftInterpolationLinear(self, i: 'unsigned int') -> "bool":
	return _npstat.DoubleNULinInterpolatedTableND_leftInterpolationLinear(self, i)

	def rightInterpolationLinear(self, i: 'unsigned int') -> "bool":
	return _npstat.DoubleNULinInterpolatedTableND_rightInterpolationLinear(self, i)

	def interpolationType(self) -> "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >":
	return _npstat.DoubleNULinInterpolatedTableND_interpolationType(self)

	def functionLabel(self) -> "std::string const &":
	return _npstat.DoubleNULinInterpolatedTableND_functionLabel(self)

	def table(self, *args) -> "npstat::ArrayND< double > &":
	return _npstat.DoubleNULinInterpolatedTableND_table(self, *args)

	def getCoords(self, linearIndex: 'unsigned long', coords: 'double *', coordsBufferSize: 'unsigned int') -> "void":
	return _npstat.DoubleNULinInterpolatedTableND_getCoords(self, linearIndex, coords, coordsBufferSize)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.DoubleNULinInterpolatedTableND_isUniformlyBinned(self)

	def isWithinLimits(self, point: 'double const *') -> "bool":
	return _npstat.DoubleNULinInterpolatedTableND_isWithinLimits(self, point)

	def setFunctionLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.DoubleNULinInterpolatedTableND_setFunctionLabel(self, newlabel)

	def __eq__(self, arg2: 'DoubleNULinInterpolatedTableND') -> "bool":
	return _npstat.DoubleNULinInterpolatedTableND___eq__(self, arg2)

	def __ne__(self, r: 'DoubleNULinInterpolatedTableND') -> "bool":
	return _npstat.DoubleNULinInterpolatedTableND___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleNULinInterpolatedTableND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleNULinInterpolatedTableND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleNULinInterpolatedTableND_classname)
	else:
	classname = _npstat.DoubleNULinInterpolatedTableND_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleNULinInterpolatedTableND_version)
	else:
	version = _npstat.DoubleNULinInterpolatedTableND_version
	if _newclass:
	read = staticmethod(_npstat.DoubleNULinInterpolatedTableND_read)
	else:
	read = _npstat.DoubleNULinInterpolatedTableND_read
	__swig_destroy__ = _npstat.delete_DoubleNULinInterpolatedTableND
	__del__ = lambda self: None
	DoubleNULinInterpolatedTableND_swigregister = _npstat.DoubleNULinInterpolatedTableND_swigregister
	DoubleNULinInterpolatedTableND_swigregister(DoubleNULinInterpolatedTableND)

	def DoubleNULinInterpolatedTableND_classname() -> "char const *":
	return _npstat.DoubleNULinInterpolatedTableND_classname()
	DoubleNULinInterpolatedTableND_classname = _npstat.DoubleNULinInterpolatedTableND_classname

	def DoubleNULinInterpolatedTableND_version() -> "unsigned int":
	return _npstat.DoubleNULinInterpolatedTableND_version()
	DoubleNULinInterpolatedTableND_version = _npstat.DoubleNULinInterpolatedTableND_version

	def DoubleNULinInterpolatedTableND_read(id: 'ClassId', arg3: 'istream') -> "npstat::LinInterpolatedTableND< double,npstat::GridAxis > *":
	return _npstat.DoubleNULinInterpolatedTableND_read(id, arg3)
	DoubleNULinInterpolatedTableND_read = _npstat.DoubleNULinInterpolatedTableND_read

	class DoubleDALinInterpolatedTableND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleDALinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleDALinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_DoubleDALinInterpolatedTableND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, *args) -> "double":
	return _npstat.DoubleDALinInterpolatedTableND___call__(self, *args)

	def dim(self) -> "unsigned int":
	return _npstat.DoubleDALinInterpolatedTableND_dim(self)

	def axes(self) -> "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &":
	return _npstat.DoubleDALinInterpolatedTableND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::DualAxis const &":
	return _npstat.DoubleDALinInterpolatedTableND_axis(self, i)

	def length(self) -> "unsigned long":
	return _npstat.DoubleDALinInterpolatedTableND_length(self)

	def leftInterpolationLinear(self, i: 'unsigned int') -> "bool":
	return _npstat.DoubleDALinInterpolatedTableND_leftInterpolationLinear(self, i)

	def rightInterpolationLinear(self, i: 'unsigned int') -> "bool":
	return _npstat.DoubleDALinInterpolatedTableND_rightInterpolationLinear(self, i)

	def interpolationType(self) -> "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >":
	return _npstat.DoubleDALinInterpolatedTableND_interpolationType(self)

	def functionLabel(self) -> "std::string const &":
	return _npstat.DoubleDALinInterpolatedTableND_functionLabel(self)

	def table(self, *args) -> "npstat::ArrayND< double > &":
	return _npstat.DoubleDALinInterpolatedTableND_table(self, *args)

	def getCoords(self, linearIndex: 'unsigned long', coords: 'double *', coordsBufferSize: 'unsigned int') -> "void":
	return _npstat.DoubleDALinInterpolatedTableND_getCoords(self, linearIndex, coords, coordsBufferSize)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.DoubleDALinInterpolatedTableND_isUniformlyBinned(self)

	def isWithinLimits(self, point: 'double const *') -> "bool":
	return _npstat.DoubleDALinInterpolatedTableND_isWithinLimits(self, point)

	def setFunctionLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.DoubleDALinInterpolatedTableND_setFunctionLabel(self, newlabel)

	def __eq__(self, arg2: 'DoubleDALinInterpolatedTableND') -> "bool":
	return _npstat.DoubleDALinInterpolatedTableND___eq__(self, arg2)

	def __ne__(self, r: 'DoubleDALinInterpolatedTableND') -> "bool":
	return _npstat.DoubleDALinInterpolatedTableND___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleDALinInterpolatedTableND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleDALinInterpolatedTableND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleDALinInterpolatedTableND_classname)
	else:
	classname = _npstat.DoubleDALinInterpolatedTableND_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleDALinInterpolatedTableND_version)
	else:
	version = _npstat.DoubleDALinInterpolatedTableND_version
	if _newclass:
	read = staticmethod(_npstat.DoubleDALinInterpolatedTableND_read)
	else:
	read = _npstat.DoubleDALinInterpolatedTableND_read
	__swig_destroy__ = _npstat.delete_DoubleDALinInterpolatedTableND
	__del__ = lambda self: None
	DoubleDALinInterpolatedTableND_swigregister = _npstat.DoubleDALinInterpolatedTableND_swigregister
	DoubleDALinInterpolatedTableND_swigregister(DoubleDALinInterpolatedTableND)

	def DoubleDALinInterpolatedTableND_classname() -> "char const *":
	return _npstat.DoubleDALinInterpolatedTableND_classname()
	DoubleDALinInterpolatedTableND_classname = _npstat.DoubleDALinInterpolatedTableND_classname

	def DoubleDALinInterpolatedTableND_version() -> "unsigned int":
	return _npstat.DoubleDALinInterpolatedTableND_version()
	DoubleDALinInterpolatedTableND_version = _npstat.DoubleDALinInterpolatedTableND_version

	def DoubleDALinInterpolatedTableND_read(id: 'ClassId', arg3: 'istream') -> "npstat::LinInterpolatedTableND< double,npstat::DualAxis > *":
	return _npstat.DoubleDALinInterpolatedTableND_read(id, arg3)
	DoubleDALinInterpolatedTableND_read = _npstat.DoubleDALinInterpolatedTableND_read

	class FloatLinInterpolatedTableND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatLinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatLinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_FloatLinInterpolatedTableND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, *args) -> "float":
	return _npstat.FloatLinInterpolatedTableND___call__(self, *args)

	def dim(self) -> "unsigned int":
	return _npstat.FloatLinInterpolatedTableND_dim(self)

	def axes(self) -> "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &":
	return _npstat.FloatLinInterpolatedTableND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::UniformAxis const &":
	return _npstat.FloatLinInterpolatedTableND_axis(self, i)

	def length(self) -> "unsigned long":
	return _npstat.FloatLinInterpolatedTableND_length(self)

	def leftInterpolationLinear(self, i: 'unsigned int') -> "bool":
	return _npstat.FloatLinInterpolatedTableND_leftInterpolationLinear(self, i)

	def rightInterpolationLinear(self, i: 'unsigned int') -> "bool":
	return _npstat.FloatLinInterpolatedTableND_rightInterpolationLinear(self, i)

	def interpolationType(self) -> "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >":
	return _npstat.FloatLinInterpolatedTableND_interpolationType(self)

	def functionLabel(self) -> "std::string const &":
	return _npstat.FloatLinInterpolatedTableND_functionLabel(self)

	def table(self, *args) -> "npstat::ArrayND< float > &":
	return _npstat.FloatLinInterpolatedTableND_table(self, *args)

	def getCoords(self, linearIndex: 'unsigned long', coords: 'double *', coordsBufferSize: 'unsigned int') -> "void":
	return _npstat.FloatLinInterpolatedTableND_getCoords(self, linearIndex, coords, coordsBufferSize)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.FloatLinInterpolatedTableND_isUniformlyBinned(self)

	def isWithinLimits(self, point: 'double const *') -> "bool":
	return _npstat.FloatLinInterpolatedTableND_isWithinLimits(self, point)

	def setFunctionLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.FloatLinInterpolatedTableND_setFunctionLabel(self, newlabel)

	def __eq__(self, arg2: 'FloatLinInterpolatedTableND') -> "bool":
	return _npstat.FloatLinInterpolatedTableND___eq__(self, arg2)

	def __ne__(self, r: 'FloatLinInterpolatedTableND') -> "bool":
	return _npstat.FloatLinInterpolatedTableND___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatLinInterpolatedTableND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatLinInterpolatedTableND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatLinInterpolatedTableND_classname)
	else:
	classname = _npstat.FloatLinInterpolatedTableND_classname
	if _newclass:
	version = staticmethod(_npstat.FloatLinInterpolatedTableND_version)
	else:
	version = _npstat.FloatLinInterpolatedTableND_version
	if _newclass:
	read = staticmethod(_npstat.FloatLinInterpolatedTableND_read)
	else:
	read = _npstat.FloatLinInterpolatedTableND_read
	__swig_destroy__ = _npstat.delete_FloatLinInterpolatedTableND
	__del__ = lambda self: None
	FloatLinInterpolatedTableND_swigregister = _npstat.FloatLinInterpolatedTableND_swigregister
	FloatLinInterpolatedTableND_swigregister(FloatLinInterpolatedTableND)

	def FloatLinInterpolatedTableND_classname() -> "char const *":
	return _npstat.FloatLinInterpolatedTableND_classname()
	FloatLinInterpolatedTableND_classname = _npstat.FloatLinInterpolatedTableND_classname

	def FloatLinInterpolatedTableND_version() -> "unsigned int":
	return _npstat.FloatLinInterpolatedTableND_version()
	FloatLinInterpolatedTableND_version = _npstat.FloatLinInterpolatedTableND_version

	def FloatLinInterpolatedTableND_read(id: 'ClassId', arg3: 'istream') -> "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *":
	return _npstat.FloatLinInterpolatedTableND_read(id, arg3)
	FloatLinInterpolatedTableND_read = _npstat.FloatLinInterpolatedTableND_read

	class FloatNULinInterpolatedTableND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatNULinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatNULinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_FloatNULinInterpolatedTableND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, *args) -> "float":
	return _npstat.FloatNULinInterpolatedTableND___call__(self, *args)

	def dim(self) -> "unsigned int":
	return _npstat.FloatNULinInterpolatedTableND_dim(self)

	def axes(self) -> "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &":
	return _npstat.FloatNULinInterpolatedTableND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::GridAxis const &":
	return _npstat.FloatNULinInterpolatedTableND_axis(self, i)

	def length(self) -> "unsigned long":
	return _npstat.FloatNULinInterpolatedTableND_length(self)

	def leftInterpolationLinear(self, i: 'unsigned int') -> "bool":
	return _npstat.FloatNULinInterpolatedTableND_leftInterpolationLinear(self, i)

	def rightInterpolationLinear(self, i: 'unsigned int') -> "bool":
	return _npstat.FloatNULinInterpolatedTableND_rightInterpolationLinear(self, i)

	def interpolationType(self) -> "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >":
	return _npstat.FloatNULinInterpolatedTableND_interpolationType(self)

	def functionLabel(self) -> "std::string const &":
	return _npstat.FloatNULinInterpolatedTableND_functionLabel(self)

	def table(self, *args) -> "npstat::ArrayND< float > &":
	return _npstat.FloatNULinInterpolatedTableND_table(self, *args)

	def getCoords(self, linearIndex: 'unsigned long', coords: 'double *', coordsBufferSize: 'unsigned int') -> "void":
	return _npstat.FloatNULinInterpolatedTableND_getCoords(self, linearIndex, coords, coordsBufferSize)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.FloatNULinInterpolatedTableND_isUniformlyBinned(self)

	def isWithinLimits(self, point: 'double const *') -> "bool":
	return _npstat.FloatNULinInterpolatedTableND_isWithinLimits(self, point)

	def setFunctionLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.FloatNULinInterpolatedTableND_setFunctionLabel(self, newlabel)

	def __eq__(self, arg2: 'FloatNULinInterpolatedTableND') -> "bool":
	return _npstat.FloatNULinInterpolatedTableND___eq__(self, arg2)

	def __ne__(self, r: 'FloatNULinInterpolatedTableND') -> "bool":
	return _npstat.FloatNULinInterpolatedTableND___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatNULinInterpolatedTableND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatNULinInterpolatedTableND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatNULinInterpolatedTableND_classname)
	else:
	classname = _npstat.FloatNULinInterpolatedTableND_classname
	if _newclass:
	version = staticmethod(_npstat.FloatNULinInterpolatedTableND_version)
	else:
	version = _npstat.FloatNULinInterpolatedTableND_version
	if _newclass:
	read = staticmethod(_npstat.FloatNULinInterpolatedTableND_read)
	else:
	read = _npstat.FloatNULinInterpolatedTableND_read
	__swig_destroy__ = _npstat.delete_FloatNULinInterpolatedTableND
	__del__ = lambda self: None
	FloatNULinInterpolatedTableND_swigregister = _npstat.FloatNULinInterpolatedTableND_swigregister
	FloatNULinInterpolatedTableND_swigregister(FloatNULinInterpolatedTableND)

	def FloatNULinInterpolatedTableND_classname() -> "char const *":
	return _npstat.FloatNULinInterpolatedTableND_classname()
	FloatNULinInterpolatedTableND_classname = _npstat.FloatNULinInterpolatedTableND_classname

	def FloatNULinInterpolatedTableND_version() -> "unsigned int":
	return _npstat.FloatNULinInterpolatedTableND_version()
	FloatNULinInterpolatedTableND_version = _npstat.FloatNULinInterpolatedTableND_version

	def FloatNULinInterpolatedTableND_read(id: 'ClassId', arg3: 'istream') -> "npstat::LinInterpolatedTableND< float,npstat::GridAxis > *":
	return _npstat.FloatNULinInterpolatedTableND_read(id, arg3)
	FloatNULinInterpolatedTableND_read = _npstat.FloatNULinInterpolatedTableND_read

	class FloatDALinInterpolatedTableND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatDALinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatDALinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_FloatDALinInterpolatedTableND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, *args) -> "float":
	return _npstat.FloatDALinInterpolatedTableND___call__(self, *args)

	def dim(self) -> "unsigned int":
	return _npstat.FloatDALinInterpolatedTableND_dim(self)

	def axes(self) -> "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &":
	return _npstat.FloatDALinInterpolatedTableND_axes(self)

	def axis(self, i: 'unsigned int const') -> "npstat::DualAxis const &":
	return _npstat.FloatDALinInterpolatedTableND_axis(self, i)

	def length(self) -> "unsigned long":
	return _npstat.FloatDALinInterpolatedTableND_length(self)

	def leftInterpolationLinear(self, i: 'unsigned int') -> "bool":
	return _npstat.FloatDALinInterpolatedTableND_leftInterpolationLinear(self, i)

	def rightInterpolationLinear(self, i: 'unsigned int') -> "bool":
	return _npstat.FloatDALinInterpolatedTableND_rightInterpolationLinear(self, i)

	def interpolationType(self) -> "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >":
	return _npstat.FloatDALinInterpolatedTableND_interpolationType(self)

	def functionLabel(self) -> "std::string const &":
	return _npstat.FloatDALinInterpolatedTableND_functionLabel(self)

	def table(self, *args) -> "npstat::ArrayND< float > &":
	return _npstat.FloatDALinInterpolatedTableND_table(self, *args)

	def getCoords(self, linearIndex: 'unsigned long', coords: 'double *', coordsBufferSize: 'unsigned int') -> "void":
	return _npstat.FloatDALinInterpolatedTableND_getCoords(self, linearIndex, coords, coordsBufferSize)

	def isUniformlyBinned(self) -> "bool":
	return _npstat.FloatDALinInterpolatedTableND_isUniformlyBinned(self)

	def isWithinLimits(self, point: 'double const *') -> "bool":
	return _npstat.FloatDALinInterpolatedTableND_isWithinLimits(self, point)

	def setFunctionLabel(self, newlabel: 'char const *') -> "void":
	return _npstat.FloatDALinInterpolatedTableND_setFunctionLabel(self, newlabel)

	def __eq__(self, arg2: 'FloatDALinInterpolatedTableND') -> "bool":
	return _npstat.FloatDALinInterpolatedTableND___eq__(self, arg2)

	def __ne__(self, r: 'FloatDALinInterpolatedTableND') -> "bool":
	return _npstat.FloatDALinInterpolatedTableND___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatDALinInterpolatedTableND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatDALinInterpolatedTableND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatDALinInterpolatedTableND_classname)
	else:
	classname = _npstat.FloatDALinInterpolatedTableND_classname
	if _newclass:
	version = staticmethod(_npstat.FloatDALinInterpolatedTableND_version)
	else:
	version = _npstat.FloatDALinInterpolatedTableND_version
	if _newclass:
	read = staticmethod(_npstat.FloatDALinInterpolatedTableND_read)
	else:
	read = _npstat.FloatDALinInterpolatedTableND_read
	__swig_destroy__ = _npstat.delete_FloatDALinInterpolatedTableND
	__del__ = lambda self: None
	FloatDALinInterpolatedTableND_swigregister = _npstat.FloatDALinInterpolatedTableND_swigregister
	FloatDALinInterpolatedTableND_swigregister(FloatDALinInterpolatedTableND)

	def FloatDALinInterpolatedTableND_classname() -> "char const *":
	return _npstat.FloatDALinInterpolatedTableND_classname()
	FloatDALinInterpolatedTableND_classname = _npstat.FloatDALinInterpolatedTableND_classname

	def FloatDALinInterpolatedTableND_version() -> "unsigned int":
	return _npstat.FloatDALinInterpolatedTableND_version()
	FloatDALinInterpolatedTableND_version = _npstat.FloatDALinInterpolatedTableND_version

	def FloatDALinInterpolatedTableND_read(id: 'ClassId', arg3: 'istream') -> "npstat::LinInterpolatedTableND< float,npstat::DualAxis > *":
	return _npstat.FloatDALinInterpolatedTableND_read(id, arg3)
	FloatDALinInterpolatedTableND_read = _npstat.FloatDALinInterpolatedTableND_read

	class ArchiveRecord_DoubleLinInterpolatedTableND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DoubleLinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DoubleLinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DoubleLinInterpolatedTableND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DoubleLinInterpolatedTableND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DoubleLinInterpolatedTableND
	__del__ = lambda self: None
	ArchiveRecord_DoubleLinInterpolatedTableND_swigregister = _npstat.ArchiveRecord_DoubleLinInterpolatedTableND_swigregister
	ArchiveRecord_DoubleLinInterpolatedTableND_swigregister(ArchiveRecord_DoubleLinInterpolatedTableND)

	class Ref_DoubleLinInterpolatedTableND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DoubleLinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DoubleLinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DoubleLinInterpolatedTableND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DoubleLinInterpolatedTableND') -> "void":
	return _npstat.Ref_DoubleLinInterpolatedTableND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *":
	return _npstat.Ref_DoubleLinInterpolatedTableND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::LinInterpolatedTableND< double,npstat::UniformAxis >":
	return _npstat.Ref_DoubleLinInterpolatedTableND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DoubleLinInterpolatedTableND
	__del__ = lambda self: None
	Ref_DoubleLinInterpolatedTableND_swigregister = _npstat.Ref_DoubleLinInterpolatedTableND_swigregister
	Ref_DoubleLinInterpolatedTableND_swigregister(Ref_DoubleLinInterpolatedTableND)

	class ArchiveRecord_DoubleNULinInterpolatedTableND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DoubleNULinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DoubleNULinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DoubleNULinInterpolatedTableND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DoubleNULinInterpolatedTableND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DoubleNULinInterpolatedTableND
	__del__ = lambda self: None
	ArchiveRecord_DoubleNULinInterpolatedTableND_swigregister = _npstat.ArchiveRecord_DoubleNULinInterpolatedTableND_swigregister
	ArchiveRecord_DoubleNULinInterpolatedTableND_swigregister(ArchiveRecord_DoubleNULinInterpolatedTableND)

	class Ref_DoubleNULinInterpolatedTableND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DoubleNULinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DoubleNULinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DoubleNULinInterpolatedTableND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DoubleNULinInterpolatedTableND') -> "void":
	return _npstat.Ref_DoubleNULinInterpolatedTableND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::LinInterpolatedTableND< double,npstat::GridAxis > *":
	return _npstat.Ref_DoubleNULinInterpolatedTableND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::LinInterpolatedTableND< double,npstat::GridAxis >":
	return _npstat.Ref_DoubleNULinInterpolatedTableND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DoubleNULinInterpolatedTableND
	__del__ = lambda self: None
	Ref_DoubleNULinInterpolatedTableND_swigregister = _npstat.Ref_DoubleNULinInterpolatedTableND_swigregister
	Ref_DoubleNULinInterpolatedTableND_swigregister(Ref_DoubleNULinInterpolatedTableND)

	class ArchiveRecord_DoubleDALinInterpolatedTableND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DoubleDALinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DoubleDALinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DoubleDALinInterpolatedTableND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DoubleDALinInterpolatedTableND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DoubleDALinInterpolatedTableND
	__del__ = lambda self: None
	ArchiveRecord_DoubleDALinInterpolatedTableND_swigregister = _npstat.ArchiveRecord_DoubleDALinInterpolatedTableND_swigregister
	ArchiveRecord_DoubleDALinInterpolatedTableND_swigregister(ArchiveRecord_DoubleDALinInterpolatedTableND)

	class Ref_DoubleDALinInterpolatedTableND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DoubleDALinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DoubleDALinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DoubleDALinInterpolatedTableND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DoubleDALinInterpolatedTableND') -> "void":
	return _npstat.Ref_DoubleDALinInterpolatedTableND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::LinInterpolatedTableND< double,npstat::DualAxis > *":
	return _npstat.Ref_DoubleDALinInterpolatedTableND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::LinInterpolatedTableND< double,npstat::DualAxis >":
	return _npstat.Ref_DoubleDALinInterpolatedTableND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DoubleDALinInterpolatedTableND
	__del__ = lambda self: None
	Ref_DoubleDALinInterpolatedTableND_swigregister = _npstat.Ref_DoubleDALinInterpolatedTableND_swigregister
	Ref_DoubleDALinInterpolatedTableND_swigregister(Ref_DoubleDALinInterpolatedTableND)

	class ArchiveRecord_FloatLinInterpolatedTableND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_FloatLinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_FloatLinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'FloatLinInterpolatedTableND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_FloatLinInterpolatedTableND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_FloatLinInterpolatedTableND
	__del__ = lambda self: None
	ArchiveRecord_FloatLinInterpolatedTableND_swigregister = _npstat.ArchiveRecord_FloatLinInterpolatedTableND_swigregister
	ArchiveRecord_FloatLinInterpolatedTableND_swigregister(ArchiveRecord_FloatLinInterpolatedTableND)

	class Ref_FloatLinInterpolatedTableND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_FloatLinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_FloatLinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_FloatLinInterpolatedTableND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'FloatLinInterpolatedTableND') -> "void":
	return _npstat.Ref_FloatLinInterpolatedTableND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *":
	return _npstat.Ref_FloatLinInterpolatedTableND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::LinInterpolatedTableND< float,npstat::UniformAxis >":
	return _npstat.Ref_FloatLinInterpolatedTableND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_FloatLinInterpolatedTableND
	__del__ = lambda self: None
	Ref_FloatLinInterpolatedTableND_swigregister = _npstat.Ref_FloatLinInterpolatedTableND_swigregister
	Ref_FloatLinInterpolatedTableND_swigregister(Ref_FloatLinInterpolatedTableND)

	class ArchiveRecord_FloatNULinInterpolatedTableND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_FloatNULinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_FloatNULinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'FloatNULinInterpolatedTableND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_FloatNULinInterpolatedTableND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_FloatNULinInterpolatedTableND
	__del__ = lambda self: None
	ArchiveRecord_FloatNULinInterpolatedTableND_swigregister = _npstat.ArchiveRecord_FloatNULinInterpolatedTableND_swigregister
	ArchiveRecord_FloatNULinInterpolatedTableND_swigregister(ArchiveRecord_FloatNULinInterpolatedTableND)

	class Ref_FloatNULinInterpolatedTableND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_FloatNULinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_FloatNULinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_FloatNULinInterpolatedTableND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'FloatNULinInterpolatedTableND') -> "void":
	return _npstat.Ref_FloatNULinInterpolatedTableND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::LinInterpolatedTableND< float,npstat::GridAxis > *":
	return _npstat.Ref_FloatNULinInterpolatedTableND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::LinInterpolatedTableND< float,npstat::GridAxis >":
	return _npstat.Ref_FloatNULinInterpolatedTableND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_FloatNULinInterpolatedTableND
	__del__ = lambda self: None
	Ref_FloatNULinInterpolatedTableND_swigregister = _npstat.Ref_FloatNULinInterpolatedTableND_swigregister
	Ref_FloatNULinInterpolatedTableND_swigregister(Ref_FloatNULinInterpolatedTableND)

	class ArchiveRecord_FloatDALinInterpolatedTableND(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_FloatDALinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_FloatDALinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'FloatDALinInterpolatedTableND', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_FloatDALinInterpolatedTableND(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_FloatDALinInterpolatedTableND
	__del__ = lambda self: None
	ArchiveRecord_FloatDALinInterpolatedTableND_swigregister = _npstat.ArchiveRecord_FloatDALinInterpolatedTableND_swigregister
	ArchiveRecord_FloatDALinInterpolatedTableND_swigregister(ArchiveRecord_FloatDALinInterpolatedTableND)

	class Ref_FloatDALinInterpolatedTableND(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_FloatDALinInterpolatedTableND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_FloatDALinInterpolatedTableND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_FloatDALinInterpolatedTableND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'FloatDALinInterpolatedTableND') -> "void":
	return _npstat.Ref_FloatDALinInterpolatedTableND_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::LinInterpolatedTableND< float,npstat::DualAxis > *":
	return _npstat.Ref_FloatDALinInterpolatedTableND_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::LinInterpolatedTableND< float,npstat::DualAxis >":
	return _npstat.Ref_FloatDALinInterpolatedTableND_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_FloatDALinInterpolatedTableND
	__del__ = lambda self: None
	Ref_FloatDALinInterpolatedTableND_swigregister = _npstat.Ref_FloatDALinInterpolatedTableND_swigregister
	Ref_FloatDALinInterpolatedTableND_swigregister(Ref_FloatDALinInterpolatedTableND)

	class FloatUAInterpolationFunctor(StorableMultivariateFunctor):
	__swig_setmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatUAInterpolationFunctor, name, value)
	__swig_getmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatUAInterpolationFunctor, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_FloatUAInterpolationFunctor(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatUAInterpolationFunctor
	__del__ = lambda self: None

	def minDim(self) -> "unsigned int":
	return _npstat.FloatUAInterpolationFunctor_minDim(self)

	def __call__(self, point: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.FloatUAInterpolationFunctor___call__(self, point, dim)

	def interpolator(self, *args) -> "npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::Table const &":
	return _npstat.FloatUAInterpolationFunctor_interpolator(self, *args)

	def table(self, *args) -> "npstat::ArrayND< float > const &":
	return _npstat.FloatUAInterpolationFunctor_table(self, *args)

	def setConverter(self, conv: 'FloatSame') -> "void":
	return _npstat.FloatUAInterpolationFunctor_setConverter(self, conv)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatUAInterpolationFunctor_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatUAInterpolationFunctor_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatUAInterpolationFunctor_classname)
	else:
	classname = _npstat.FloatUAInterpolationFunctor_classname
	if _newclass:
	version = staticmethod(_npstat.FloatUAInterpolationFunctor_version)
	else:
	version = _npstat.FloatUAInterpolationFunctor_version
	if _newclass:
	read = staticmethod(_npstat.FloatUAInterpolationFunctor_read)
	else:
	read = _npstat.FloatUAInterpolationFunctor_read
	FloatUAInterpolationFunctor_swigregister = _npstat.FloatUAInterpolationFunctor_swigregister
	FloatUAInterpolationFunctor_swigregister(FloatUAInterpolationFunctor)

	def FloatUAInterpolationFunctor_classname() -> "char const *":
	return _npstat.FloatUAInterpolationFunctor_classname()
	FloatUAInterpolationFunctor_classname = _npstat.FloatUAInterpolationFunctor_classname

	def FloatUAInterpolationFunctor_version() -> "unsigned int":
	return _npstat.FloatUAInterpolationFunctor_version()
	FloatUAInterpolationFunctor_version = _npstat.FloatUAInterpolationFunctor_version

	def FloatUAInterpolationFunctor_read(id: 'ClassId', arg3: 'istream') -> "npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *":
	return _npstat.FloatUAInterpolationFunctor_read(id, arg3)
	FloatUAInterpolationFunctor_read = _npstat.FloatUAInterpolationFunctor_read

	class FloatNUInterpolationFunctor(StorableMultivariateFunctor):
	__swig_setmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatNUInterpolationFunctor, name, value)
	__swig_getmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatNUInterpolationFunctor, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_FloatNUInterpolationFunctor(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatNUInterpolationFunctor
	__del__ = lambda self: None

	def minDim(self) -> "unsigned int":
	return _npstat.FloatNUInterpolationFunctor_minDim(self)

	def __call__(self, point: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.FloatNUInterpolationFunctor___call__(self, point, dim)

	def interpolator(self, *args) -> "npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::Table const &":
	return _npstat.FloatNUInterpolationFunctor_interpolator(self, *args)

	def table(self, *args) -> "npstat::ArrayND< float > const &":
	return _npstat.FloatNUInterpolationFunctor_table(self, *args)

	def setConverter(self, conv: 'FloatSame') -> "void":
	return _npstat.FloatNUInterpolationFunctor_setConverter(self, conv)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatNUInterpolationFunctor_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatNUInterpolationFunctor_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatNUInterpolationFunctor_classname)
	else:
	classname = _npstat.FloatNUInterpolationFunctor_classname
	if _newclass:
	version = staticmethod(_npstat.FloatNUInterpolationFunctor_version)
	else:
	version = _npstat.FloatNUInterpolationFunctor_version
	if _newclass:
	read = staticmethod(_npstat.FloatNUInterpolationFunctor_read)
	else:
	read = _npstat.FloatNUInterpolationFunctor_read
	FloatNUInterpolationFunctor_swigregister = _npstat.FloatNUInterpolationFunctor_swigregister
	FloatNUInterpolationFunctor_swigregister(FloatNUInterpolationFunctor)

	def FloatNUInterpolationFunctor_classname() -> "char const *":
	return _npstat.FloatNUInterpolationFunctor_classname()
	FloatNUInterpolationFunctor_classname = _npstat.FloatNUInterpolationFunctor_classname

	def FloatNUInterpolationFunctor_version() -> "unsigned int":
	return _npstat.FloatNUInterpolationFunctor_version()
	FloatNUInterpolationFunctor_version = _npstat.FloatNUInterpolationFunctor_version

	def FloatNUInterpolationFunctor_read(id: 'ClassId', arg3: 'istream') -> "npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *":
	return _npstat.FloatNUInterpolationFunctor_read(id, arg3)
	FloatNUInterpolationFunctor_read = _npstat.FloatNUInterpolationFunctor_read

	class FloatInterpolationFunctor(StorableMultivariateFunctor):
	__swig_setmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatInterpolationFunctor, name, value)
	__swig_getmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatInterpolationFunctor, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_FloatInterpolationFunctor(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatInterpolationFunctor
	__del__ = lambda self: None

	def minDim(self) -> "unsigned int":
	return _npstat.FloatInterpolationFunctor_minDim(self)

	def __call__(self, point: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.FloatInterpolationFunctor___call__(self, point, dim)

	def interpolator(self, *args) -> "npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::Table const &":
	return _npstat.FloatInterpolationFunctor_interpolator(self, *args)

	def table(self, *args) -> "npstat::ArrayND< float > const &":
	return _npstat.FloatInterpolationFunctor_table(self, *args)

	def setConverter(self, conv: 'FloatSame') -> "void":
	return _npstat.FloatInterpolationFunctor_setConverter(self, conv)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatInterpolationFunctor_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatInterpolationFunctor_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatInterpolationFunctor_classname)
	else:
	classname = _npstat.FloatInterpolationFunctor_classname
	if _newclass:
	version = staticmethod(_npstat.FloatInterpolationFunctor_version)
	else:
	version = _npstat.FloatInterpolationFunctor_version
	if _newclass:
	read = staticmethod(_npstat.FloatInterpolationFunctor_read)
	else:
	read = _npstat.FloatInterpolationFunctor_read
	FloatInterpolationFunctor_swigregister = _npstat.FloatInterpolationFunctor_swigregister
	FloatInterpolationFunctor_swigregister(FloatInterpolationFunctor)

	def FloatInterpolationFunctor_classname() -> "char const *":
	return _npstat.FloatInterpolationFunctor_classname()
	FloatInterpolationFunctor_classname = _npstat.FloatInterpolationFunctor_classname

	def FloatInterpolationFunctor_version() -> "unsigned int":
	return _npstat.FloatInterpolationFunctor_version()
	FloatInterpolationFunctor_version = _npstat.FloatInterpolationFunctor_version

	def FloatInterpolationFunctor_read(id: 'ClassId', arg3: 'istream') -> "npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *":
	return _npstat.FloatInterpolationFunctor_read(id, arg3)
	FloatInterpolationFunctor_read = _npstat.FloatInterpolationFunctor_read

	class DoubleUAInterpolationFunctor(StorableMultivariateFunctor):
	__swig_setmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleUAInterpolationFunctor, name, value)
	__swig_getmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleUAInterpolationFunctor, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_DoubleUAInterpolationFunctor(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleUAInterpolationFunctor
	__del__ = lambda self: None

	def minDim(self) -> "unsigned int":
	return _npstat.DoubleUAInterpolationFunctor_minDim(self)

	def __call__(self, point: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.DoubleUAInterpolationFunctor___call__(self, point, dim)

	def interpolator(self, *args) -> "npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::Table const &":
	return _npstat.DoubleUAInterpolationFunctor_interpolator(self, *args)

	def table(self, *args) -> "npstat::ArrayND< double > const &":
	return _npstat.DoubleUAInterpolationFunctor_table(self, *args)

	def setConverter(self, conv: 'DoubleSame') -> "void":
	return _npstat.DoubleUAInterpolationFunctor_setConverter(self, conv)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleUAInterpolationFunctor_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleUAInterpolationFunctor_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleUAInterpolationFunctor_classname)
	else:
	classname = _npstat.DoubleUAInterpolationFunctor_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleUAInterpolationFunctor_version)
	else:
	version = _npstat.DoubleUAInterpolationFunctor_version
	if _newclass:
	read = staticmethod(_npstat.DoubleUAInterpolationFunctor_read)
	else:
	read = _npstat.DoubleUAInterpolationFunctor_read
	DoubleUAInterpolationFunctor_swigregister = _npstat.DoubleUAInterpolationFunctor_swigregister
	DoubleUAInterpolationFunctor_swigregister(DoubleUAInterpolationFunctor)

	def DoubleUAInterpolationFunctor_classname() -> "char const *":
	return _npstat.DoubleUAInterpolationFunctor_classname()
	DoubleUAInterpolationFunctor_classname = _npstat.DoubleUAInterpolationFunctor_classname

	def DoubleUAInterpolationFunctor_version() -> "unsigned int":
	return _npstat.DoubleUAInterpolationFunctor_version()
	DoubleUAInterpolationFunctor_version = _npstat.DoubleUAInterpolationFunctor_version

	def DoubleUAInterpolationFunctor_read(id: 'ClassId', arg3: 'istream') -> "npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *":
	return _npstat.DoubleUAInterpolationFunctor_read(id, arg3)
	DoubleUAInterpolationFunctor_read = _npstat.DoubleUAInterpolationFunctor_read

	class DoubleNUInterpolationFunctor(StorableMultivariateFunctor):
	__swig_setmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleNUInterpolationFunctor, name, value)
	__swig_getmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleNUInterpolationFunctor, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_DoubleNUInterpolationFunctor(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleNUInterpolationFunctor
	__del__ = lambda self: None

	def minDim(self) -> "unsigned int":
	return _npstat.DoubleNUInterpolationFunctor_minDim(self)

	def __call__(self, point: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.DoubleNUInterpolationFunctor___call__(self, point, dim)

	def interpolator(self, *args) -> "npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::Table const &":
	return _npstat.DoubleNUInterpolationFunctor_interpolator(self, *args)

	def table(self, *args) -> "npstat::ArrayND< double > const &":
	return _npstat.DoubleNUInterpolationFunctor_table(self, *args)

	def setConverter(self, conv: 'DoubleSame') -> "void":
	return _npstat.DoubleNUInterpolationFunctor_setConverter(self, conv)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleNUInterpolationFunctor_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleNUInterpolationFunctor_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleNUInterpolationFunctor_classname)
	else:
	classname = _npstat.DoubleNUInterpolationFunctor_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleNUInterpolationFunctor_version)
	else:
	version = _npstat.DoubleNUInterpolationFunctor_version
	if _newclass:
	read = staticmethod(_npstat.DoubleNUInterpolationFunctor_read)
	else:
	read = _npstat.DoubleNUInterpolationFunctor_read
	DoubleNUInterpolationFunctor_swigregister = _npstat.DoubleNUInterpolationFunctor_swigregister
	DoubleNUInterpolationFunctor_swigregister(DoubleNUInterpolationFunctor)

	def DoubleNUInterpolationFunctor_classname() -> "char const *":
	return _npstat.DoubleNUInterpolationFunctor_classname()
	DoubleNUInterpolationFunctor_classname = _npstat.DoubleNUInterpolationFunctor_classname

	def DoubleNUInterpolationFunctor_version() -> "unsigned int":
	return _npstat.DoubleNUInterpolationFunctor_version()
	DoubleNUInterpolationFunctor_version = _npstat.DoubleNUInterpolationFunctor_version

	def DoubleNUInterpolationFunctor_read(id: 'ClassId', arg3: 'istream') -> "npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *":
	return _npstat.DoubleNUInterpolationFunctor_read(id, arg3)
	DoubleNUInterpolationFunctor_read = _npstat.DoubleNUInterpolationFunctor_read

	class DoubleInterpolationFunctor(StorableMultivariateFunctor):
	__swig_setmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleInterpolationFunctor, name, value)
	__swig_getmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleInterpolationFunctor, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_DoubleInterpolationFunctor(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleInterpolationFunctor
	__del__ = lambda self: None

	def minDim(self) -> "unsigned int":
	return _npstat.DoubleInterpolationFunctor_minDim(self)

	def __call__(self, point: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.DoubleInterpolationFunctor___call__(self, point, dim)

	def interpolator(self, *args) -> "npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::Table const &":
	return _npstat.DoubleInterpolationFunctor_interpolator(self, *args)

	def table(self, *args) -> "npstat::ArrayND< double > const &":
	return _npstat.DoubleInterpolationFunctor_table(self, *args)

	def setConverter(self, conv: 'DoubleSame') -> "void":
	return _npstat.DoubleInterpolationFunctor_setConverter(self, conv)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleInterpolationFunctor_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleInterpolationFunctor_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleInterpolationFunctor_classname)
	else:
	classname = _npstat.DoubleInterpolationFunctor_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleInterpolationFunctor_version)
	else:
	version = _npstat.DoubleInterpolationFunctor_version
	if _newclass:
	read = staticmethod(_npstat.DoubleInterpolationFunctor_read)
	else:
	read = _npstat.DoubleInterpolationFunctor_read
	DoubleInterpolationFunctor_swigregister = _npstat.DoubleInterpolationFunctor_swigregister
	DoubleInterpolationFunctor_swigregister(DoubleInterpolationFunctor)

	def DoubleInterpolationFunctor_classname() -> "char const *":
	return _npstat.DoubleInterpolationFunctor_classname()
	DoubleInterpolationFunctor_classname = _npstat.DoubleInterpolationFunctor_classname

	def DoubleInterpolationFunctor_version() -> "unsigned int":
	return _npstat.DoubleInterpolationFunctor_version()
	DoubleInterpolationFunctor_version = _npstat.DoubleInterpolationFunctor_version

	def DoubleInterpolationFunctor_read(id: 'ClassId', arg3: 'istream') -> "npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *":
	return _npstat.DoubleInterpolationFunctor_read(id, arg3)
	DoubleInterpolationFunctor_read = _npstat.DoubleInterpolationFunctor_read

	class GaussianMixtureEntry(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, GaussianMixtureEntry, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, GaussianMixtureEntry, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_GaussianMixtureEntry(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def weight(self) -> "double":
	return _npstat.GaussianMixtureEntry_weight(self)

	def mean(self) -> "double":
	return _npstat.GaussianMixtureEntry_mean(self)

	def stdev(self) -> "double":
	return _npstat.GaussianMixtureEntry_stdev(self)

	def __eq__(self, r: 'GaussianMixtureEntry') -> "bool":
	return _npstat.GaussianMixtureEntry___eq__(self, r)

	def __ne__(self, r: 'GaussianMixtureEntry') -> "bool":
	return _npstat.GaussianMixtureEntry___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.GaussianMixtureEntry_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.GaussianMixtureEntry_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.GaussianMixtureEntry_classname)
	else:
	classname = _npstat.GaussianMixtureEntry_classname
	if _newclass:
	version = staticmethod(_npstat.GaussianMixtureEntry_version)
	else:
	version = _npstat.GaussianMixtureEntry_version
	if _newclass:
	restore = staticmethod(_npstat.GaussianMixtureEntry_restore)
	else:
	restore = _npstat.GaussianMixtureEntry_restore
	__swig_destroy__ = _npstat.delete_GaussianMixtureEntry
	__del__ = lambda self: None
	GaussianMixtureEntry_swigregister = _npstat.GaussianMixtureEntry_swigregister
	GaussianMixtureEntry_swigregister(GaussianMixtureEntry)

	def GaussianMixtureEntry_classname() -> "char const *":
	return _npstat.GaussianMixtureEntry_classname()
	GaussianMixtureEntry_classname = _npstat.GaussianMixtureEntry_classname

	def GaussianMixtureEntry_version() -> "unsigned int":
	return _npstat.GaussianMixtureEntry_version()
	GaussianMixtureEntry_version = _npstat.GaussianMixtureEntry_version

	def GaussianMixtureEntry_restore(id: 'ClassId', arg3: 'istream', entry: 'GaussianMixtureEntry') -> "void":
	return _npstat.GaussianMixtureEntry_restore(id, arg3, entry)
	GaussianMixtureEntry_restore = _npstat.GaussianMixtureEntry_restore

	class GaussianMixtureEntryVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, GaussianMixtureEntryVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, GaussianMixtureEntryVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.GaussianMixtureEntryVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.GaussianMixtureEntryVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.GaussianMixtureEntryVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::GaussianMixtureEntry >::size_type":
	return _npstat.GaussianMixtureEntryVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::GaussianMixtureEntry >::difference_type', j: 'std::vector< npstat::GaussianMixtureEntry >::difference_type') -> "std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > *":
	return _npstat.GaussianMixtureEntryVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.GaussianMixtureEntryVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::GaussianMixtureEntry >::difference_type', j: 'std::vector< npstat::GaussianMixtureEntry >::difference_type') -> "void":
	return _npstat.GaussianMixtureEntryVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.GaussianMixtureEntryVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::GaussianMixtureEntry >::value_type const &":
	return _npstat.GaussianMixtureEntryVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.GaussianMixtureEntryVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::GaussianMixtureEntry >::value_type":
	return _npstat.GaussianMixtureEntryVector_pop(self)

	def append(self, x: 'GaussianMixtureEntry') -> "void":
	return _npstat.GaussianMixtureEntryVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.GaussianMixtureEntryVector_empty(self)

	def size(self) -> "std::vector< npstat::GaussianMixtureEntry >::size_type":
	return _npstat.GaussianMixtureEntryVector_size(self)

	def swap(self, v: 'GaussianMixtureEntryVector') -> "void":
	return _npstat.GaussianMixtureEntryVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::GaussianMixtureEntry >::iterator":
	return _npstat.GaussianMixtureEntryVector_begin(self)

	def end(self) -> "std::vector< npstat::GaussianMixtureEntry >::iterator":
	return _npstat.GaussianMixtureEntryVector_end(self)

	def rbegin(self) -> "std::vector< npstat::GaussianMixtureEntry >::reverse_iterator":
	return _npstat.GaussianMixtureEntryVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::GaussianMixtureEntry >::reverse_iterator":
	return _npstat.GaussianMixtureEntryVector_rend(self)

	def clear(self) -> "void":
	return _npstat.GaussianMixtureEntryVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::GaussianMixtureEntry >::allocator_type":
	return _npstat.GaussianMixtureEntryVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.GaussianMixtureEntryVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::GaussianMixtureEntry >::iterator":
	return _npstat.GaussianMixtureEntryVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_GaussianMixtureEntryVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'GaussianMixtureEntry') -> "void":
	return _npstat.GaussianMixtureEntryVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::GaussianMixtureEntry >::value_type const &":
	return _npstat.GaussianMixtureEntryVector_front(self)

	def back(self) -> "std::vector< npstat::GaussianMixtureEntry >::value_type const &":
	return _npstat.GaussianMixtureEntryVector_back(self)

	def assign(self, n: 'std::vector< npstat::GaussianMixtureEntry >::size_type', x: 'GaussianMixtureEntry') -> "void":
	return _npstat.GaussianMixtureEntryVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.GaussianMixtureEntryVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.GaussianMixtureEntryVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::GaussianMixtureEntry >::size_type') -> "void":
	return _npstat.GaussianMixtureEntryVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::GaussianMixtureEntry >::size_type":
	return _npstat.GaussianMixtureEntryVector_capacity(self)
	__swig_destroy__ = _npstat.delete_GaussianMixtureEntryVector
	__del__ = lambda self: None
	GaussianMixtureEntryVector_swigregister = _npstat.GaussianMixtureEntryVector_swigregister
	GaussianMixtureEntryVector_swigregister(GaussianMixtureEntryVector)

	class DiscreteTabulated1D(ShiftableDiscreteDistribution1D):
	__swig_setmethods__ = {}
	for _s in [ShiftableDiscreteDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DiscreteTabulated1D, name, value)
	__swig_getmethods__ = {}
	for _s in [ShiftableDiscreteDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DiscreteTabulated1D, name)
	__repr__ = _swig_repr

	def __init__(self, shift: 'long const', probs: 'DoubleVector'):
	this = _npstat.new_DiscreteTabulated1D(shift, probs)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DiscreteTabulated1D
	__del__ = lambda self: None

	def clone(self) -> "npstat::DiscreteTabulated1D *":
	return _npstat.DiscreteTabulated1D_clone(self)

	def probabilities(self) -> "std::vector< double,std::allocator< double > > const &":
	return _npstat.DiscreteTabulated1D_probabilities(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.DiscreteTabulated1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.DiscreteTabulated1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.DiscreteTabulated1D_classname)
	else:
	classname = _npstat.DiscreteTabulated1D_classname
	if _newclass:
	version = staticmethod(_npstat.DiscreteTabulated1D_version)
	else:
	version = _npstat.DiscreteTabulated1D_version
	if _newclass:
	read = staticmethod(_npstat.DiscreteTabulated1D_read)
	else:
	read = _npstat.DiscreteTabulated1D_read
	DiscreteTabulated1D_swigregister = _npstat.DiscreteTabulated1D_swigregister
	DiscreteTabulated1D_swigregister(DiscreteTabulated1D)

	def DiscreteTabulated1D_classname() -> "char const *":
	return _npstat.DiscreteTabulated1D_classname()
	DiscreteTabulated1D_classname = _npstat.DiscreteTabulated1D_classname

	def DiscreteTabulated1D_version() -> "unsigned int":
	return _npstat.DiscreteTabulated1D_version()
	DiscreteTabulated1D_version = _npstat.DiscreteTabulated1D_version

	def DiscreteTabulated1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::DiscreteTabulated1D *":
	return _npstat.DiscreteTabulated1D_read(id, arg3)
	DiscreteTabulated1D_read = _npstat.DiscreteTabulated1D_read


	def pooledDiscreteTabulated1D(d1: 'DiscreteTabulated1D', sampleSize1: 'double', d2: 'DiscreteTabulated1D', sampleSize2: 'double', first: 'long', oneAfterLast: 'long') -> "npstat::DiscreteTabulated1D":
	return _npstat.pooledDiscreteTabulated1D(d1, sampleSize1, d2, sampleSize2, first, oneAfterLast)
	pooledDiscreteTabulated1D = _npstat.pooledDiscreteTabulated1D
	class Poisson1D(AbsDiscreteDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsDiscreteDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Poisson1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsDiscreteDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Poisson1D, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Poisson1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::Poisson1D *":
	return _npstat.Poisson1D_clone(self)
	__swig_destroy__ = _npstat.delete_Poisson1D
	__del__ = lambda self: None

	def mean(self) -> "double":
	return _npstat.Poisson1D_mean(self)

	def probability(self, x: 'long') -> "double":
	return _npstat.Poisson1D_probability(self, x)

	def cdf(self, x: 'double') -> "double":
	return _npstat.Poisson1D_cdf(self, x)

	def exceedance(self, x: 'double') -> "double":
	return _npstat.Poisson1D_exceedance(self, x)

	def quantile(self, x: 'double') -> "long":
	return _npstat.Poisson1D_quantile(self, x)

	def classId(self) -> "gs::ClassId":
	return _npstat.Poisson1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.Poisson1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.Poisson1D_classname)
	else:
	classname = _npstat.Poisson1D_classname
	if _newclass:
	version = staticmethod(_npstat.Poisson1D_version)
	else:
	version = _npstat.Poisson1D_version
	if _newclass:
	read = staticmethod(_npstat.Poisson1D_read)
	else:
	read = _npstat.Poisson1D_read
	Poisson1D_swigregister = _npstat.Poisson1D_swigregister
	Poisson1D_swigregister(Poisson1D)

	def Poisson1D_classname() -> "char const *":
	return _npstat.Poisson1D_classname()
	Poisson1D_classname = _npstat.Poisson1D_classname

	def Poisson1D_version() -> "unsigned int":
	return _npstat.Poisson1D_version()
	Poisson1D_version = _npstat.Poisson1D_version

	def Poisson1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::Poisson1D *":
	return _npstat.Poisson1D_read(id, arg3)
	Poisson1D_read = _npstat.Poisson1D_read

	class ArchiveRecord_DiscreteTabulated1D(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_DiscreteTabulated1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_DiscreteTabulated1D, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DiscreteTabulated1D', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_DiscreteTabulated1D(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_DiscreteTabulated1D
	__del__ = lambda self: None
	ArchiveRecord_DiscreteTabulated1D_swigregister = _npstat.ArchiveRecord_DiscreteTabulated1D_swigregister
	ArchiveRecord_DiscreteTabulated1D_swigregister(ArchiveRecord_DiscreteTabulated1D)

	class Ref_DiscreteTabulated1D(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DiscreteTabulated1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DiscreteTabulated1D, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DiscreteTabulated1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DiscreteTabulated1D') -> "void":
	return _npstat.Ref_DiscreteTabulated1D_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::DiscreteTabulated1D *":
	return _npstat.Ref_DiscreteTabulated1D_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::DiscreteTabulated1D":
	return _npstat.Ref_DiscreteTabulated1D_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DiscreteTabulated1D
	__del__ = lambda self: None
	Ref_DiscreteTabulated1D_swigregister = _npstat.Ref_DiscreteTabulated1D_swigregister
	Ref_DiscreteTabulated1D_swigregister(Ref_DiscreteTabulated1D)

	class ArchiveRecord_Poisson1D(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_Poisson1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_Poisson1D, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'Poisson1D', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_Poisson1D(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_Poisson1D
	__del__ = lambda self: None
	ArchiveRecord_Poisson1D_swigregister = _npstat.ArchiveRecord_Poisson1D_swigregister
	ArchiveRecord_Poisson1D_swigregister(ArchiveRecord_Poisson1D)

	class Ref_Poisson1D(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_Poisson1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_Poisson1D, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_Poisson1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'Poisson1D') -> "void":
	return _npstat.Ref_Poisson1D_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::Poisson1D *":
	return _npstat.Ref_Poisson1D_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::Poisson1D":
	return _npstat.Ref_Poisson1D_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_Poisson1D
	__del__ = lambda self: None
	Ref_Poisson1D_swigregister = _npstat.Ref_Poisson1D_swigregister
	Ref_Poisson1D_swigregister(Ref_Poisson1D)

	class LogMapper1d(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LogMapper1d, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LogMapper1d, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_LogMapper1d(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, x: 'double const &') -> "double":
	return _npstat.LogMapper1d___call__(self, x)

	def a(self) -> "double":
	return _npstat.LogMapper1d_a(self)

	def b(self) -> "double":
	return _npstat.LogMapper1d_b(self)
	__swig_destroy__ = _npstat.delete_LogMapper1d
	__del__ = lambda self: None
	LogMapper1d_swigregister = _npstat.LogMapper1d_swigregister
	LogMapper1d_swigregister(LogMapper1d)

	class LogMapper1dVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LogMapper1dVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LogMapper1dVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.LogMapper1dVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.LogMapper1dVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.LogMapper1dVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::LogMapper1d >::size_type":
	return _npstat.LogMapper1dVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::LogMapper1d >::difference_type', j: 'std::vector< npstat::LogMapper1d >::difference_type') -> "std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > *":
	return _npstat.LogMapper1dVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.LogMapper1dVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::LogMapper1d >::difference_type', j: 'std::vector< npstat::LogMapper1d >::difference_type') -> "void":
	return _npstat.LogMapper1dVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.LogMapper1dVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::LogMapper1d >::value_type const &":
	return _npstat.LogMapper1dVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.LogMapper1dVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::LogMapper1d >::value_type":
	return _npstat.LogMapper1dVector_pop(self)

	def append(self, x: 'LogMapper1d') -> "void":
	return _npstat.LogMapper1dVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.LogMapper1dVector_empty(self)

	def size(self) -> "std::vector< npstat::LogMapper1d >::size_type":
	return _npstat.LogMapper1dVector_size(self)

	def swap(self, v: 'LogMapper1dVector') -> "void":
	return _npstat.LogMapper1dVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::LogMapper1d >::iterator":
	return _npstat.LogMapper1dVector_begin(self)

	def end(self) -> "std::vector< npstat::LogMapper1d >::iterator":
	return _npstat.LogMapper1dVector_end(self)

	def rbegin(self) -> "std::vector< npstat::LogMapper1d >::reverse_iterator":
	return _npstat.LogMapper1dVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::LogMapper1d >::reverse_iterator":
	return _npstat.LogMapper1dVector_rend(self)

	def clear(self) -> "void":
	return _npstat.LogMapper1dVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::LogMapper1d >::allocator_type":
	return _npstat.LogMapper1dVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.LogMapper1dVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::LogMapper1d >::iterator":
	return _npstat.LogMapper1dVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_LogMapper1dVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'LogMapper1d') -> "void":
	return _npstat.LogMapper1dVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::LogMapper1d >::value_type const &":
	return _npstat.LogMapper1dVector_front(self)

	def back(self) -> "std::vector< npstat::LogMapper1d >::value_type const &":
	return _npstat.LogMapper1dVector_back(self)

	def assign(self, n: 'std::vector< npstat::LogMapper1d >::size_type', x: 'LogMapper1d') -> "void":
	return _npstat.LogMapper1dVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.LogMapper1dVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.LogMapper1dVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::LogMapper1d >::size_type') -> "void":
	return _npstat.LogMapper1dVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::LogMapper1d >::size_type":
	return _npstat.LogMapper1dVector_capacity(self)
	__swig_destroy__ = _npstat.delete_LogMapper1dVector
	__del__ = lambda self: None
	LogMapper1dVector_swigregister = _npstat.LogMapper1dVector_swigregister
	LogMapper1dVector_swigregister(LogMapper1dVector)

	class LinInterpolatedTable1D(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LinInterpolatedTable1D, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LinInterpolatedTable1D, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LinInterpolatedTable1D
	__del__ = lambda self: None

	def __call__(self, x: 'double const &') -> "double":
	return _npstat.LinInterpolatedTable1D___call__(self, x)

	def __eq__(self, r: 'LinInterpolatedTable1D') -> "bool":
	return _npstat.LinInterpolatedTable1D___eq__(self, r)

	def __ne__(self, r: 'LinInterpolatedTable1D') -> "bool":
	return _npstat.LinInterpolatedTable1D___ne__(self, r)

	def xmin(self) -> "double":
	return _npstat.LinInterpolatedTable1D_xmin(self)

	def xmax(self) -> "double":
	return _npstat.LinInterpolatedTable1D_xmax(self)

	def npoints(self) -> "unsigned int":
	return _npstat.LinInterpolatedTable1D_npoints(self)

	def leftExtrapolationLinear(self) -> "bool":
	return _npstat.LinInterpolatedTable1D_leftExtrapolationLinear(self)

	def rightExtrapolationLinear(self) -> "bool":
	return _npstat.LinInterpolatedTable1D_rightExtrapolationLinear(self)

	def data(self) -> "double const *":
	return _npstat.LinInterpolatedTable1D_data(self)

	def isMonotonous(self) -> "bool":
	return _npstat.LinInterpolatedTable1D_isMonotonous(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.LinInterpolatedTable1D_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.LinInterpolatedTable1D_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.LinInterpolatedTable1D_classname)
	else:
	classname = _npstat.LinInterpolatedTable1D_classname
	if _newclass:
	version = staticmethod(_npstat.LinInterpolatedTable1D_version)
	else:
	version = _npstat.LinInterpolatedTable1D_version
	if _newclass:
	read = staticmethod(_npstat.LinInterpolatedTable1D_read)
	else:
	read = _npstat.LinInterpolatedTable1D_read

	def inverse(self, npoints: 'unsigned int', leftExtrapolationLinear: 'bool', rightExtrapolationLinear: 'bool') -> "npstat::LinInterpolatedTable1D *":
	return _npstat.LinInterpolatedTable1D_inverse(self, npoints, leftExtrapolationLinear, rightExtrapolationLinear)

	def __init__(self, *args):
	this = _npstat.new_LinInterpolatedTable1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	LinInterpolatedTable1D_swigregister = _npstat.LinInterpolatedTable1D_swigregister
	LinInterpolatedTable1D_swigregister(LinInterpolatedTable1D)

	def LinInterpolatedTable1D_classname() -> "char const *":
	return _npstat.LinInterpolatedTable1D_classname()
	LinInterpolatedTable1D_classname = _npstat.LinInterpolatedTable1D_classname

	def LinInterpolatedTable1D_version() -> "unsigned int":
	return _npstat.LinInterpolatedTable1D_version()
	LinInterpolatedTable1D_version = _npstat.LinInterpolatedTable1D_version

	def LinInterpolatedTable1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::LinInterpolatedTable1D *":
	return _npstat.LinInterpolatedTable1D_read(id, arg3)
	LinInterpolatedTable1D_read = _npstat.LinInterpolatedTable1D_read

	class ArchiveRecord_LinInterpolatedTable1D(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_LinInterpolatedTable1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_LinInterpolatedTable1D, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'LinInterpolatedTable1D', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_LinInterpolatedTable1D(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_LinInterpolatedTable1D
	__del__ = lambda self: None
	ArchiveRecord_LinInterpolatedTable1D_swigregister = _npstat.ArchiveRecord_LinInterpolatedTable1D_swigregister
	ArchiveRecord_LinInterpolatedTable1D_swigregister(ArchiveRecord_LinInterpolatedTable1D)

	class Ref_LinInterpolatedTable1D(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_LinInterpolatedTable1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_LinInterpolatedTable1D, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_LinInterpolatedTable1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'LinInterpolatedTable1D') -> "void":
	return _npstat.Ref_LinInterpolatedTable1D_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::LinInterpolatedTable1D *":
	return _npstat.Ref_LinInterpolatedTable1D_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::LinInterpolatedTable1D":
	return _npstat.Ref_LinInterpolatedTable1D_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_LinInterpolatedTable1D
	__del__ = lambda self: None
	Ref_LinInterpolatedTable1D_swigregister = _npstat.Ref_LinInterpolatedTable1D_swigregister
	Ref_LinInterpolatedTable1D_swigregister(Ref_LinInterpolatedTable1D)

	class LinInterpolatedTable1DVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LinInterpolatedTable1DVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LinInterpolatedTable1DVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.LinInterpolatedTable1DVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.LinInterpolatedTable1DVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.LinInterpolatedTable1DVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::LinInterpolatedTable1D >::size_type":
	return _npstat.LinInterpolatedTable1DVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::LinInterpolatedTable1D >::difference_type', j: 'std::vector< npstat::LinInterpolatedTable1D >::difference_type') -> "std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > *":
	return _npstat.LinInterpolatedTable1DVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.LinInterpolatedTable1DVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::LinInterpolatedTable1D >::difference_type', j: 'std::vector< npstat::LinInterpolatedTable1D >::difference_type') -> "void":
	return _npstat.LinInterpolatedTable1DVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.LinInterpolatedTable1DVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::LinInterpolatedTable1D >::value_type const &":
	return _npstat.LinInterpolatedTable1DVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.LinInterpolatedTable1DVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::LinInterpolatedTable1D >::value_type":
	return _npstat.LinInterpolatedTable1DVector_pop(self)

	def append(self, x: 'LinInterpolatedTable1D') -> "void":
	return _npstat.LinInterpolatedTable1DVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.LinInterpolatedTable1DVector_empty(self)

	def size(self) -> "std::vector< npstat::LinInterpolatedTable1D >::size_type":
	return _npstat.LinInterpolatedTable1DVector_size(self)

	def swap(self, v: 'LinInterpolatedTable1DVector') -> "void":
	return _npstat.LinInterpolatedTable1DVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::LinInterpolatedTable1D >::iterator":
	return _npstat.LinInterpolatedTable1DVector_begin(self)

	def end(self) -> "std::vector< npstat::LinInterpolatedTable1D >::iterator":
	return _npstat.LinInterpolatedTable1DVector_end(self)

	def rbegin(self) -> "std::vector< npstat::LinInterpolatedTable1D >::reverse_iterator":
	return _npstat.LinInterpolatedTable1DVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::LinInterpolatedTable1D >::reverse_iterator":
	return _npstat.LinInterpolatedTable1DVector_rend(self)

	def clear(self) -> "void":
	return _npstat.LinInterpolatedTable1DVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::LinInterpolatedTable1D >::allocator_type":
	return _npstat.LinInterpolatedTable1DVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.LinInterpolatedTable1DVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::LinInterpolatedTable1D >::iterator":
	return _npstat.LinInterpolatedTable1DVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_LinInterpolatedTable1DVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'LinInterpolatedTable1D') -> "void":
	return _npstat.LinInterpolatedTable1DVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::LinInterpolatedTable1D >::value_type const &":
	return _npstat.LinInterpolatedTable1DVector_front(self)

	def back(self) -> "std::vector< npstat::LinInterpolatedTable1D >::value_type const &":
	return _npstat.LinInterpolatedTable1DVector_back(self)

	def assign(self, n: 'std::vector< npstat::LinInterpolatedTable1D >::size_type', x: 'LinInterpolatedTable1D') -> "void":
	return _npstat.LinInterpolatedTable1DVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.LinInterpolatedTable1DVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.LinInterpolatedTable1DVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::LinInterpolatedTable1D >::size_type') -> "void":
	return _npstat.LinInterpolatedTable1DVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::LinInterpolatedTable1D >::size_type":
	return _npstat.LinInterpolatedTable1DVector_capacity(self)
	__swig_destroy__ = _npstat.delete_LinInterpolatedTable1DVector
	__del__ = lambda self: None
	LinInterpolatedTable1DVector_swigregister = _npstat.LinInterpolatedTable1DVector_swigregister
	LinInterpolatedTable1DVector_swigregister(LinInterpolatedTable1DVector)

	class DensityScan1D(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DensityScan1D, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DensityScan1D, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistribution1D', normfactor: 'double', nbins: 'unsigned long', xmin: 'double', xmax: 'double', nIntegrationPoints: 'unsigned int'=1):
	this = _npstat.new_DensityScan1D(fcn, normfactor, nbins, xmin, xmax, nIntegrationPoints)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, index: 'unsigned int const *', len: 'unsigned int') -> "double":
	return _npstat.DensityScan1D___call__(self, index, len)

	def averageDensity(self, binNumber: 'unsigned int const') -> "double":
	return _npstat.DensityScan1D_averageDensity(self, binNumber)
	__swig_destroy__ = _npstat.delete_DensityScan1D
	__del__ = lambda self: None
	DensityScan1D_swigregister = _npstat.DensityScan1D_swigregister
	DensityScan1D_swigregister(DensityScan1D)

	class DensityDiscretizationError1D(DoubleDoubleFunctor1):
	__swig_setmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DensityDiscretizationError1D, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleDoubleFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DensityDiscretizationError1D, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistribution1D', normfactor: 'double const', discreteValue: 'double const'):
	this = _npstat.new_DensityDiscretizationError1D(fcn, normfactor, discreteValue)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DensityDiscretizationError1D
	__del__ = lambda self: None

	def __call__(self, a: 'double const &') -> "double":
	return _npstat.DensityDiscretizationError1D___call__(self, a)
	DensityDiscretizationError1D_swigregister = _npstat.DensityDiscretizationError1D_swigregister
	DensityDiscretizationError1D_swigregister(DensityDiscretizationError1D)

	class DensityScan1D_Linear(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DensityScan1D_Linear, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DensityScan1D_Linear, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistribution1D', transform: 'LinearMapper1d', normfactor: 'double const'):
	this = _npstat.new_DensityScan1D_Linear(fcn, transform, normfactor)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, index: 'unsigned int const *', len: 'unsigned int const') -> "double":
	return _npstat.DensityScan1D_Linear___call__(self, index, len)
	__swig_destroy__ = _npstat.delete_DensityScan1D_Linear
	__del__ = lambda self: None
	DensityScan1D_Linear_swigregister = _npstat.DensityScan1D_Linear_swigregister
	DensityScan1D_Linear_swigregister(DensityScan1D_Linear)

	class DensityScan1D_Log(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DensityScan1D_Log, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DensityScan1D_Log, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistribution1D', transform: 'LogMapper1d', normfactor: 'double const'):
	this = _npstat.new_DensityScan1D_Log(fcn, transform, normfactor)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, index: 'unsigned int const *', len: 'unsigned int const') -> "double":
	return _npstat.DensityScan1D_Log___call__(self, index, len)
	__swig_destroy__ = _npstat.delete_DensityScan1D_Log
	__del__ = lambda self: None
	DensityScan1D_Log_swigregister = _npstat.DensityScan1D_Log_swigregister
	DensityScan1D_Log_swigregister(DensityScan1D_Log)

	class DensityScan1D_Circular(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DensityScan1D_Circular, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DensityScan1D_Circular, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistribution1D', transform: 'CircularMapper1d', normfactor: 'double const'):
	this = _npstat.new_DensityScan1D_Circular(fcn, transform, normfactor)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, index: 'unsigned int const *', len: 'unsigned int const') -> "double":
	return _npstat.DensityScan1D_Circular___call__(self, index, len)
	__swig_destroy__ = _npstat.delete_DensityScan1D_Circular
	__del__ = lambda self: None
	DensityScan1D_Circular_swigregister = _npstat.DensityScan1D_Circular_swigregister
	DensityScan1D_Circular_swigregister(DensityScan1D_Circular)

	class DensityScan1D_Interpolated(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DensityScan1D_Interpolated, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DensityScan1D_Interpolated, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistribution1D', transform: 'LinInterpolatedTable1D', normfactor: 'double const'):
	this = _npstat.new_DensityScan1D_Interpolated(fcn, transform, normfactor)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, index: 'unsigned int const *', len: 'unsigned int const') -> "double":
	return _npstat.DensityScan1D_Interpolated___call__(self, index, len)
	__swig_destroy__ = _npstat.delete_DensityScan1D_Interpolated
	__del__ = lambda self: None
	DensityScan1D_Interpolated_swigregister = _npstat.DensityScan1D_Interpolated_swigregister
	DensityScan1D_Interpolated_swigregister(DensityScan1D_Interpolated)

	class DensityScan1D_Funct(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DensityScan1D_Funct, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DensityScan1D_Funct, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistribution1D', transform: 'DoubleDoubleFunctor1', normfactor: 'double const'):
	this = _npstat.new_DensityScan1D_Funct(fcn, transform, normfactor)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, index: 'unsigned int const *', len: 'unsigned int const') -> "double":
	return _npstat.DensityScan1D_Funct___call__(self, index, len)
	__swig_destroy__ = _npstat.delete_DensityScan1D_Funct
	__del__ = lambda self: None
	DensityScan1D_Funct_swigregister = _npstat.DensityScan1D_Funct_swigregister
	DensityScan1D_Funct_swigregister(DensityScan1D_Funct)

	class DensityScan1D_Fcn(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DensityScan1D_Fcn, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DensityScan1D_Fcn, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistribution1D', transform: 'DoubleDoubleFcnFunctor1', normfactor: 'double const'):
	this = _npstat.new_DensityScan1D_Fcn(fcn, transform, normfactor)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, index: 'unsigned int const *', len: 'unsigned int const') -> "double":
	return _npstat.DensityScan1D_Fcn___call__(self, index, len)
	__swig_destroy__ = _npstat.delete_DensityScan1D_Fcn
	__del__ = lambda self: None
	DensityScan1D_Fcn_swigregister = _npstat.DensityScan1D_Fcn_swigregister
	DensityScan1D_Fcn_swigregister(DensityScan1D_Fcn)

	class AbsInterpolatedDistribution1D(AbsDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsInterpolatedDistribution1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, AbsInterpolatedDistribution1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsInterpolatedDistribution1D
	__del__ = lambda self: None

	def clone(self) -> "npstat::AbsInterpolatedDistribution1D *":
	return _npstat.AbsInterpolatedDistribution1D_clone(self)

	def add(self, d: 'AbsDistribution1D', weight: 'double') -> "void":
	return _npstat.AbsInterpolatedDistribution1D_add(self, d, weight)

	def replace(self, i: 'unsigned int', d: 'AbsDistribution1D', weight: 'double') -> "void":
	return _npstat.AbsInterpolatedDistribution1D_replace(self, i, d, weight)

	def setWeight(self, i: 'unsigned int', weight: 'double') -> "void":
	return _npstat.AbsInterpolatedDistribution1D_setWeight(self, i, weight)

	def clear(self) -> "void":
	return _npstat.AbsInterpolatedDistribution1D_clear(self)

	def size(self) -> "unsigned int":
	return _npstat.AbsInterpolatedDistribution1D_size(self)

	def expectedSize(self) -> "unsigned int":
	return _npstat.AbsInterpolatedDistribution1D_expectedSize(self)

	def normalizeAutomatically(self, allow: 'bool') -> "void":
	return _npstat.AbsInterpolatedDistribution1D_normalizeAutomatically(self, allow)
	AbsInterpolatedDistribution1D_swigregister = _npstat.AbsInterpolatedDistribution1D_swigregister
	AbsInterpolatedDistribution1D_swigregister(AbsInterpolatedDistribution1D)

	class VerticallyInterpolatedDistribution1D(AbsInterpolatedDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsInterpolatedDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, VerticallyInterpolatedDistribution1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsInterpolatedDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, VerticallyInterpolatedDistribution1D, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_VerticallyInterpolatedDistribution1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_VerticallyInterpolatedDistribution1D
	__del__ = lambda self: None

	def clone(self) -> "npstat::VerticallyInterpolatedDistribution1D *":
	return _npstat.VerticallyInterpolatedDistribution1D_clone(self)

	def add(self, d: 'AbsDistribution1D', weight: 'double') -> "void":
	return _npstat.VerticallyInterpolatedDistribution1D_add(self, d, weight)

	def replace(self, i: 'unsigned int', d: 'AbsDistribution1D', weight: 'double') -> "void":
	return _npstat.VerticallyInterpolatedDistribution1D_replace(self, i, d, weight)

	def setWeight(self, i: 'unsigned int', weight: 'double') -> "void":
	return _npstat.VerticallyInterpolatedDistribution1D_setWeight(self, i, weight)

	def clear(self) -> "void":
	return _npstat.VerticallyInterpolatedDistribution1D_clear(self)

	def normalizeAutomatically(self, allow: 'bool') -> "void":
	return _npstat.VerticallyInterpolatedDistribution1D_normalizeAutomatically(self, allow)

	def size(self) -> "unsigned int":
	return _npstat.VerticallyInterpolatedDistribution1D_size(self)

	def expectedSize(self) -> "unsigned int":
	return _npstat.VerticallyInterpolatedDistribution1D_expectedSize(self)

	def density(self, x: 'double') -> "double":
	return _npstat.VerticallyInterpolatedDistribution1D_density(self, x)

	def cdf(self, x: 'double') -> "double":
	return _npstat.VerticallyInterpolatedDistribution1D_cdf(self, x)

	def exceedance(self, x: 'double') -> "double":
	return _npstat.VerticallyInterpolatedDistribution1D_exceedance(self, x)

	def quantile(self, x: 'double') -> "double":
	return _npstat.VerticallyInterpolatedDistribution1D_quantile(self, x)

	def classId(self) -> "gs::ClassId":
	return _npstat.VerticallyInterpolatedDistribution1D_classId(self)
	if _newclass:
	classname = staticmethod(_npstat.VerticallyInterpolatedDistribution1D_classname)
	else:
	classname = _npstat.VerticallyInterpolatedDistribution1D_classname
	if _newclass:
	version = staticmethod(_npstat.VerticallyInterpolatedDistribution1D_version)
	else:
	version = _npstat.VerticallyInterpolatedDistribution1D_version
	VerticallyInterpolatedDistribution1D_swigregister = _npstat.VerticallyInterpolatedDistribution1D_swigregister
	VerticallyInterpolatedDistribution1D_swigregister(VerticallyInterpolatedDistribution1D)

	def VerticallyInterpolatedDistribution1D_classname() -> "char const *":
	return _npstat.VerticallyInterpolatedDistribution1D_classname()
	VerticallyInterpolatedDistribution1D_classname = _npstat.VerticallyInterpolatedDistribution1D_classname

	def VerticallyInterpolatedDistribution1D_version() -> "unsigned int":
	return _npstat.VerticallyInterpolatedDistribution1D_version()
	VerticallyInterpolatedDistribution1D_version = _npstat.VerticallyInterpolatedDistribution1D_version

	class UCharAbsBandwidthCV1D(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharAbsBandwidthCV1D, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharAbsBandwidthCV1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_UCharAbsBandwidthCV1D
	__del__ = lambda self: None

	def __call__(self, *args) -> "double":
	return _npstat.UCharAbsBandwidthCV1D___call__(self, *args)
	UCharAbsBandwidthCV1D_swigregister = _npstat.UCharAbsBandwidthCV1D_swigregister
	UCharAbsBandwidthCV1D_swigregister(UCharAbsBandwidthCV1D)

	class IntAbsBandwidthCV1D(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntAbsBandwidthCV1D, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntAbsBandwidthCV1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_IntAbsBandwidthCV1D
	__del__ = lambda self: None

	def __call__(self, *args) -> "double":
	return _npstat.IntAbsBandwidthCV1D___call__(self, *args)
	IntAbsBandwidthCV1D_swigregister = _npstat.IntAbsBandwidthCV1D_swigregister
	IntAbsBandwidthCV1D_swigregister(IntAbsBandwidthCV1D)

	class LLongAbsBandwidthCV1D(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongAbsBandwidthCV1D, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongAbsBandwidthCV1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LLongAbsBandwidthCV1D
	__del__ = lambda self: None

	def __call__(self, *args) -> "double":
	return _npstat.LLongAbsBandwidthCV1D___call__(self, *args)
	LLongAbsBandwidthCV1D_swigregister = _npstat.LLongAbsBandwidthCV1D_swigregister
	LLongAbsBandwidthCV1D_swigregister(LLongAbsBandwidthCV1D)

	class FloatAbsBandwidthCV1D(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatAbsBandwidthCV1D, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatAbsBandwidthCV1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatAbsBandwidthCV1D
	__del__ = lambda self: None

	def __call__(self, *args) -> "double":
	return _npstat.FloatAbsBandwidthCV1D___call__(self, *args)
	FloatAbsBandwidthCV1D_swigregister = _npstat.FloatAbsBandwidthCV1D_swigregister
	FloatAbsBandwidthCV1D_swigregister(FloatAbsBandwidthCV1D)

	class DoubleAbsBandwidthCV1D(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleAbsBandwidthCV1D, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleAbsBandwidthCV1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleAbsBandwidthCV1D
	__del__ = lambda self: None

	def __call__(self, *args) -> "double":
	return _npstat.DoubleAbsBandwidthCV1D___call__(self, *args)
	DoubleAbsBandwidthCV1D_swigregister = _npstat.DoubleAbsBandwidthCV1D_swigregister
	DoubleAbsBandwidthCV1D_swigregister(DoubleAbsBandwidthCV1D)

	class UCharAbsBandwidthCVND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharAbsBandwidthCVND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharAbsBandwidthCVND, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_UCharAbsBandwidthCVND
	__del__ = lambda self: None

	def __call__(self, *args) -> "double":
	return _npstat.UCharAbsBandwidthCVND___call__(self, *args)
	UCharAbsBandwidthCVND_swigregister = _npstat.UCharAbsBandwidthCVND_swigregister
	UCharAbsBandwidthCVND_swigregister(UCharAbsBandwidthCVND)

	class IntAbsBandwidthCVND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntAbsBandwidthCVND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntAbsBandwidthCVND, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_IntAbsBandwidthCVND
	__del__ = lambda self: None

	def __call__(self, *args) -> "double":
	return _npstat.IntAbsBandwidthCVND___call__(self, *args)
	IntAbsBandwidthCVND_swigregister = _npstat.IntAbsBandwidthCVND_swigregister
	IntAbsBandwidthCVND_swigregister(IntAbsBandwidthCVND)

	class LLongAbsBandwidthCVND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongAbsBandwidthCVND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongAbsBandwidthCVND, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LLongAbsBandwidthCVND
	__del__ = lambda self: None

	def __call__(self, *args) -> "double":
	return _npstat.LLongAbsBandwidthCVND___call__(self, *args)
	LLongAbsBandwidthCVND_swigregister = _npstat.LLongAbsBandwidthCVND_swigregister
	LLongAbsBandwidthCVND_swigregister(LLongAbsBandwidthCVND)

	class FloatAbsBandwidthCVND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatAbsBandwidthCVND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatAbsBandwidthCVND, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatAbsBandwidthCVND
	__del__ = lambda self: None

	def __call__(self, *args) -> "double":
	return _npstat.FloatAbsBandwidthCVND___call__(self, *args)
	FloatAbsBandwidthCVND_swigregister = _npstat.FloatAbsBandwidthCVND_swigregister
	FloatAbsBandwidthCVND_swigregister(FloatAbsBandwidthCVND)

	class DoubleAbsBandwidthCVND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleAbsBandwidthCVND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleAbsBandwidthCVND, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleAbsBandwidthCVND
	__del__ = lambda self: None

	def __call__(self, *args) -> "double":
	return _npstat.DoubleAbsBandwidthCVND___call__(self, *args)
	DoubleAbsBandwidthCVND_swigregister = _npstat.DoubleAbsBandwidthCVND_swigregister
	DoubleAbsBandwidthCVND_swigregister(DoubleAbsBandwidthCVND)

	class ConstantBandwidthSmootherND_4(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, ConstantBandwidthSmootherND_4, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, ConstantBandwidthSmootherND_4, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_ConstantBandwidthSmootherND_4
	__del__ = lambda self: None

	def dim(self) -> "unsigned int":
	return _npstat.ConstantBandwidthSmootherND_4_dim(self)

	def shape(self) -> "npstat::ArrayShape const &":
	return _npstat.ConstantBandwidthSmootherND_4_shape(self)

	def shapeData(self) -> "unsigned int const *":
	return _npstat.ConstantBandwidthSmootherND_4_shapeData(self)

	def maxDegree(self) -> "unsigned int":
	return _npstat.ConstantBandwidthSmootherND_4_maxDegree(self)

	def mirrorsData(self) -> "bool":
	return _npstat.ConstantBandwidthSmootherND_4_mirrorsData(self)

	def taper(self, degree: 'unsigned int') -> "double":
	return _npstat.ConstantBandwidthSmootherND_4_taper(self, degree)

	def __init__(self, *args):
	this = _npstat.new_ConstantBandwidthSmootherND_4(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def smoothHistogram(self, *args) -> "void":
	return _npstat.ConstantBandwidthSmootherND_4_smoothHistogram(self, *args)
	ConstantBandwidthSmootherND_4_swigregister = _npstat.ConstantBandwidthSmootherND_4_swigregister
	ConstantBandwidthSmootherND_4_swigregister(ConstantBandwidthSmootherND_4)

	class RightCensoredDistribution(AbsDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, RightCensoredDistribution, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, RightCensoredDistribution, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_RightCensoredDistribution(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::RightCensoredDistribution *":
	return _npstat.RightCensoredDistribution_clone(self)
	__swig_destroy__ = _npstat.delete_RightCensoredDistribution
	__del__ = lambda self: None

	def visible(self) -> "npstat::AbsDistribution1D const &":
	return _npstat.RightCensoredDistribution_visible(self)

	def visibleFraction(self) -> "double":
	return _npstat.RightCensoredDistribution_visibleFraction(self)

	def effectiveInfinity(self) -> "double":
	return _npstat.RightCensoredDistribution_effectiveInfinity(self)

	def density(self, x: 'double') -> "double":
	return _npstat.RightCensoredDistribution_density(self, x)

	def cdf(self, x: 'double') -> "double":
	return _npstat.RightCensoredDistribution_cdf(self, x)

	def exceedance(self, x: 'double') -> "double":
	return _npstat.RightCensoredDistribution_exceedance(self, x)

	def quantile(self, x: 'double') -> "double":
	return _npstat.RightCensoredDistribution_quantile(self, x)

	def classId(self) -> "gs::ClassId":
	return _npstat.RightCensoredDistribution_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.RightCensoredDistribution_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.RightCensoredDistribution_classname)
	else:
	classname = _npstat.RightCensoredDistribution_classname
	if _newclass:
	version = staticmethod(_npstat.RightCensoredDistribution_version)
	else:
	version = _npstat.RightCensoredDistribution_version
	if _newclass:
	read = staticmethod(_npstat.RightCensoredDistribution_read)
	else:
	read = _npstat.RightCensoredDistribution_read
	RightCensoredDistribution_swigregister = _npstat.RightCensoredDistribution_swigregister
	RightCensoredDistribution_swigregister(RightCensoredDistribution)

	def RightCensoredDistribution_classname() -> "char const *":
	return _npstat.RightCensoredDistribution_classname()
	RightCensoredDistribution_classname = _npstat.RightCensoredDistribution_classname

	def RightCensoredDistribution_version() -> "unsigned int":
	return _npstat.RightCensoredDistribution_version()
	RightCensoredDistribution_version = _npstat.RightCensoredDistribution_version

	def RightCensoredDistribution_read(id: 'ClassId', arg3: 'istream') -> "npstat::RightCensoredDistribution *":
	return _npstat.RightCensoredDistribution_read(id, arg3)
	RightCensoredDistribution_read = _npstat.RightCensoredDistribution_read


	def amisePluginBwGauss(filterDegree: 'unsigned int', npoints: 'double', sampleSigma: 'double', expectedAmise: 'double *'=None) -> "double":
	return _npstat.amisePluginBwGauss(filterDegree, npoints, sampleSigma, expectedAmise)
	amisePluginBwGauss = _npstat.amisePluginBwGauss

	def approxAmisePluginBwGauss(filterDegree: 'double', npoints: 'double', sampleSigma: 'double') -> "double":
	return _npstat.approxAmisePluginBwGauss(filterDegree, npoints, sampleSigma)
	approxAmisePluginBwGauss = _npstat.approxAmisePluginBwGauss

	def amisePluginBwSymbeta(power: 'unsigned int', filterDegree: 'unsigned int', npoints: 'double', sampleSigma: 'double', expectedAmise: 'double *'=None) -> "double":
	return _npstat.amisePluginBwSymbeta(power, filterDegree, npoints, sampleSigma, expectedAmise)
	amisePluginBwSymbeta = _npstat.amisePluginBwSymbeta

	def symbetaBandwidthRatio(power: 'int', filterDegree: 'unsigned int') -> "double":
	return _npstat.symbetaBandwidthRatio(power, filterDegree)
	symbetaBandwidthRatio = _npstat.symbetaBandwidthRatio

	def approxSymbetaBandwidthRatio(power: 'int', filterDegree: 'double') -> "double":
	return _npstat.approxSymbetaBandwidthRatio(power, filterDegree)
	approxSymbetaBandwidthRatio = _npstat.approxSymbetaBandwidthRatio

	def amisePluginDegreeGauss(npoints: 'double') -> "unsigned int":
	return _npstat.amisePluginDegreeGauss(npoints)
	amisePluginDegreeGauss = _npstat.amisePluginDegreeGauss

	def amisePluginDegreeSymbeta(power: 'unsigned int', npoints: 'double') -> "unsigned int":
	return _npstat.amisePluginDegreeSymbeta(power, npoints)
	amisePluginDegreeSymbeta = _npstat.amisePluginDegreeSymbeta

	def maxFilterDegreeSupported() -> "unsigned int":
	return _npstat.maxFilterDegreeSupported()
	maxFilterDegreeSupported = _npstat.maxFilterDegreeSupported

	def integralOfSymmetricBetaSquared(*args) -> "double":
	return _npstat.integralOfSymmetricBetaSquared(*args)
	integralOfSymmetricBetaSquared = _npstat.integralOfSymmetricBetaSquared
	class GaussianMixture1D(AbsScalableDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, GaussianMixture1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, GaussianMixture1D, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_GaussianMixture1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_GaussianMixture1D
	__del__ = lambda self: None

	def clone(self) -> "npstat::GaussianMixture1D *":
	return _npstat.GaussianMixture1D_clone(self)

	def nentries(self) -> "unsigned int":
	return _npstat.GaussianMixture1D_nentries(self)

	def entry(self, n: 'unsigned int const') -> "npstat::GaussianMixtureEntry const &":
	return _npstat.GaussianMixture1D_entry(self, n)

	def entries(self) -> "std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > const &":
	return _npstat.GaussianMixture1D_entries(self)

	def mean(self) -> "double":
	return _npstat.GaussianMixture1D_mean(self)

	def stdev(self) -> "double":
	return _npstat.GaussianMixture1D_stdev(self)

	def gaussianMISE(self, maxPolyDegree: 'unsigned int', bandwidth: 'double', npoints: 'unsigned long') -> "double":
	return _npstat.GaussianMixture1D_gaussianMISE(self, maxPolyDegree, bandwidth, npoints)

	def miseOptimalBw(self, maxPolyDegree: 'unsigned int', npoints: 'unsigned long', mise: 'double *'=None) -> "double":
	return _npstat.GaussianMixture1D_miseOptimalBw(self, maxPolyDegree, npoints, mise)

	def classId(self) -> "gs::ClassId":
	return _npstat.GaussianMixture1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.GaussianMixture1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.GaussianMixture1D_classname)
	else:
	classname = _npstat.GaussianMixture1D_classname
	if _newclass:
	version = staticmethod(_npstat.GaussianMixture1D_version)
	else:
	version = _npstat.GaussianMixture1D_version
	if _newclass:
	read = staticmethod(_npstat.GaussianMixture1D_read)
	else:
	read = _npstat.GaussianMixture1D_read
	GaussianMixture1D_swigregister = _npstat.GaussianMixture1D_swigregister
	GaussianMixture1D_swigregister(GaussianMixture1D)

	def GaussianMixture1D_classname() -> "char const *":
	return _npstat.GaussianMixture1D_classname()
	GaussianMixture1D_classname = _npstat.GaussianMixture1D_classname

	def GaussianMixture1D_version() -> "unsigned int":
	return _npstat.GaussianMixture1D_version()
	GaussianMixture1D_version = _npstat.GaussianMixture1D_version

	def GaussianMixture1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::GaussianMixture1D *":
	return _npstat.GaussianMixture1D_read(id, arg3)
	GaussianMixture1D_read = _npstat.GaussianMixture1D_read

	class DensityScanND_Linear(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DensityScanND_Linear, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DensityScanND_Linear, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistributionND', maps: 'LinearMapper1dVector', normfactor: 'double'=1.0):
	this = _npstat.new_DensityScanND_Linear(fcn, maps, normfactor)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, index: 'unsigned int const *', indexLen: 'unsigned int const') -> "double":
	return _npstat.DensityScanND_Linear___call__(self, index, indexLen)
	__swig_destroy__ = _npstat.delete_DensityScanND_Linear
	__del__ = lambda self: None
	DensityScanND_Linear_swigregister = _npstat.DensityScanND_Linear_swigregister
	DensityScanND_Linear_swigregister(DensityScanND_Linear)

	class DensityScanND_Log(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DensityScanND_Log, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DensityScanND_Log, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistributionND', maps: 'LogMapper1dVector', normfactor: 'double'=1.0):
	this = _npstat.new_DensityScanND_Log(fcn, maps, normfactor)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, index: 'unsigned int const *', indexLen: 'unsigned int const') -> "double":
	return _npstat.DensityScanND_Log___call__(self, index, indexLen)
	__swig_destroy__ = _npstat.delete_DensityScanND_Log
	__del__ = lambda self: None
	DensityScanND_Log_swigregister = _npstat.DensityScanND_Log_swigregister
	DensityScanND_Log_swigregister(DensityScanND_Log)

	class DensityScanND_Circular(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DensityScanND_Circular, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DensityScanND_Circular, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistributionND', maps: 'CircularMapper1dVector', normfactor: 'double'=1.0):
	this = _npstat.new_DensityScanND_Circular(fcn, maps, normfactor)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, index: 'unsigned int const *', indexLen: 'unsigned int const') -> "double":
	return _npstat.DensityScanND_Circular___call__(self, index, indexLen)
	__swig_destroy__ = _npstat.delete_DensityScanND_Circular
	__del__ = lambda self: None
	DensityScanND_Circular_swigregister = _npstat.DensityScanND_Circular_swigregister
	DensityScanND_Circular_swigregister(DensityScanND_Circular)

	class DensityScanND_Interpolated(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DensityScanND_Interpolated, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DensityScanND_Interpolated, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsDistributionND', maps: 'LinInterpolatedTable1DVector', normfactor: 'double'=1.0):
	this = _npstat.new_DensityScanND_Interpolated(fcn, maps, normfactor)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, index: 'unsigned int const *', indexLen: 'unsigned int const') -> "double":
	return _npstat.DensityScanND_Interpolated___call__(self, index, indexLen)
	__swig_destroy__ = _npstat.delete_DensityScanND_Interpolated
	__del__ = lambda self: None
	DensityScanND_Interpolated_swigregister = _npstat.DensityScanND_Interpolated_swigregister
	DensityScanND_Interpolated_swigregister(DensityScanND_Interpolated)

	class AbsPolyFilterND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsPolyFilterND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, AbsPolyFilterND, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsPolyFilterND
	__del__ = lambda self: None

	def dim(self) -> "unsigned int":
	return _npstat.AbsPolyFilterND_dim(self)

	def dataShape(self) -> "std::vector< unsigned int,std::allocator< unsigned int > >":
	return _npstat.AbsPolyFilterND_dataShape(self)

	def selfContribution(self, index: 'unsigned int const *', lenIndex: 'unsigned int') -> "double":
	return _npstat.AbsPolyFilterND_selfContribution(self, index, lenIndex)

	def linearSelfContribution(self, index: 'unsigned long') -> "double":
	return _npstat.AbsPolyFilterND_linearSelfContribution(self, index)
	AbsPolyFilterND_swigregister = _npstat.AbsPolyFilterND_swigregister
	AbsPolyFilterND_swigregister(AbsPolyFilterND)

	class DoubleDoubleAbsVisitor(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleDoubleAbsVisitor, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleDoubleAbsVisitor, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleDoubleAbsVisitor
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.DoubleDoubleAbsVisitor_clear(self)

	def process(self, value: 'double const &') -> "void":
	return _npstat.DoubleDoubleAbsVisitor_process(self, value)

	def result(self) -> "double":
	return _npstat.DoubleDoubleAbsVisitor_result(self)
	DoubleDoubleAbsVisitor_swigregister = _npstat.DoubleDoubleAbsVisitor_swigregister
	DoubleDoubleAbsVisitor_swigregister(DoubleDoubleAbsVisitor)

	class FloatFloatAbsVisitor(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatFloatAbsVisitor, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatFloatAbsVisitor, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatFloatAbsVisitor
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.FloatFloatAbsVisitor_clear(self)

	def process(self, value: 'float const &') -> "void":
	return _npstat.FloatFloatAbsVisitor_process(self, value)

	def result(self) -> "float":
	return _npstat.FloatFloatAbsVisitor_result(self)
	FloatFloatAbsVisitor_swigregister = _npstat.FloatFloatAbsVisitor_swigregister
	FloatFloatAbsVisitor_swigregister(FloatFloatAbsVisitor)

	class IntIntAbsVisitor(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntIntAbsVisitor, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntIntAbsVisitor, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_IntIntAbsVisitor
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.IntIntAbsVisitor_clear(self)

	def process(self, value: 'int const &') -> "void":
	return _npstat.IntIntAbsVisitor_process(self, value)

	def result(self) -> "int":
	return _npstat.IntIntAbsVisitor_result(self)
	IntIntAbsVisitor_swigregister = _npstat.IntIntAbsVisitor_swigregister
	IntIntAbsVisitor_swigregister(IntIntAbsVisitor)

	class LLongLLongAbsVisitor(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongLLongAbsVisitor, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongLLongAbsVisitor, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LLongLLongAbsVisitor
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.LLongLLongAbsVisitor_clear(self)

	def process(self, value: 'long long const &') -> "void":
	return _npstat.LLongLLongAbsVisitor_process(self, value)

	def result(self) -> "long long":
	return _npstat.LLongLLongAbsVisitor_result(self)
	LLongLLongAbsVisitor_swigregister = _npstat.LLongLLongAbsVisitor_swigregister
	LLongLLongAbsVisitor_swigregister(LLongLLongAbsVisitor)

	class UCharUCharAbsVisitor(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharUCharAbsVisitor, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharUCharAbsVisitor, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_UCharUCharAbsVisitor
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.UCharUCharAbsVisitor_clear(self)

	def process(self, value: 'unsigned char const &') -> "void":
	return _npstat.UCharUCharAbsVisitor_process(self, value)

	def result(self) -> "unsigned char":
	return _npstat.UCharUCharAbsVisitor_result(self)
	UCharUCharAbsVisitor_swigregister = _npstat.UCharUCharAbsVisitor_swigregister
	UCharUCharAbsVisitor_swigregister(UCharUCharAbsVisitor)

	class FloatDoubleAbsVisitor(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatDoubleAbsVisitor, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatDoubleAbsVisitor, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatDoubleAbsVisitor
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.FloatDoubleAbsVisitor_clear(self)

	def process(self, value: 'float const &') -> "void":
	return _npstat.FloatDoubleAbsVisitor_process(self, value)

	def result(self) -> "double":
	return _npstat.FloatDoubleAbsVisitor_result(self)
	FloatDoubleAbsVisitor_swigregister = _npstat.FloatDoubleAbsVisitor_swigregister
	FloatDoubleAbsVisitor_swigregister(FloatDoubleAbsVisitor)

	class IntDoubleAbsVisitor(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntDoubleAbsVisitor, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntDoubleAbsVisitor, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_IntDoubleAbsVisitor
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.IntDoubleAbsVisitor_clear(self)

	def process(self, value: 'int const &') -> "void":
	return _npstat.IntDoubleAbsVisitor_process(self, value)

	def result(self) -> "double":
	return _npstat.IntDoubleAbsVisitor_result(self)
	IntDoubleAbsVisitor_swigregister = _npstat.IntDoubleAbsVisitor_swigregister
	IntDoubleAbsVisitor_swigregister(IntDoubleAbsVisitor)

	class LLongDoubleAbsVisitor(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongDoubleAbsVisitor, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongDoubleAbsVisitor, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LLongDoubleAbsVisitor
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.LLongDoubleAbsVisitor_clear(self)

	def process(self, value: 'long long const &') -> "void":
	return _npstat.LLongDoubleAbsVisitor_process(self, value)

	def result(self) -> "double":
	return _npstat.LLongDoubleAbsVisitor_result(self)
	LLongDoubleAbsVisitor_swigregister = _npstat.LLongDoubleAbsVisitor_swigregister
	LLongDoubleAbsVisitor_swigregister(LLongDoubleAbsVisitor)

	class UCharDoubleAbsVisitor(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharDoubleAbsVisitor, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharDoubleAbsVisitor, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_UCharDoubleAbsVisitor
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.UCharDoubleAbsVisitor_clear(self)

	def process(self, value: 'unsigned char const &') -> "void":
	return _npstat.UCharDoubleAbsVisitor_process(self, value)

	def result(self) -> "double":
	return _npstat.UCharDoubleAbsVisitor_result(self)
	UCharDoubleAbsVisitor_swigregister = _npstat.UCharDoubleAbsVisitor_swigregister
	UCharDoubleAbsVisitor_swigregister(UCharDoubleAbsVisitor)

	class UCharArrayMinProjector(UCharUCharAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [UCharUCharAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharArrayMinProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [UCharUCharAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UCharArrayMinProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_UCharArrayMinProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UCharArrayMinProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.UCharArrayMinProjector_clear(self)

	def result(self) -> "unsigned char":
	return _npstat.UCharArrayMinProjector_result(self)

	def process(self, value: 'unsigned char const &') -> "void":
	return _npstat.UCharArrayMinProjector_process(self, value)
	UCharArrayMinProjector_swigregister = _npstat.UCharArrayMinProjector_swigregister
	UCharArrayMinProjector_swigregister(UCharArrayMinProjector)

	class IntArrayMinProjector(IntIntAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [IntIntAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntArrayMinProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [IntIntAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, IntArrayMinProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_IntArrayMinProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_IntArrayMinProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.IntArrayMinProjector_clear(self)

	def result(self) -> "int":
	return _npstat.IntArrayMinProjector_result(self)

	def process(self, value: 'int const &') -> "void":
	return _npstat.IntArrayMinProjector_process(self, value)
	IntArrayMinProjector_swigregister = _npstat.IntArrayMinProjector_swigregister
	IntArrayMinProjector_swigregister(IntArrayMinProjector)

	class LLongArrayMinProjector(LLongLLongAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [LLongLLongAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongArrayMinProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [LLongLLongAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LLongArrayMinProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_LLongArrayMinProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_LLongArrayMinProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.LLongArrayMinProjector_clear(self)

	def result(self) -> "long long":
	return _npstat.LLongArrayMinProjector_result(self)

	def process(self, value: 'long long const &') -> "void":
	return _npstat.LLongArrayMinProjector_process(self, value)
	LLongArrayMinProjector_swigregister = _npstat.LLongArrayMinProjector_swigregister
	LLongArrayMinProjector_swigregister(LLongArrayMinProjector)

	class FloatArrayMinProjector(FloatFloatAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [FloatFloatAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatArrayMinProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [FloatFloatAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatArrayMinProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_FloatArrayMinProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatArrayMinProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.FloatArrayMinProjector_clear(self)

	def result(self) -> "float":
	return _npstat.FloatArrayMinProjector_result(self)

	def process(self, value: 'float const &') -> "void":
	return _npstat.FloatArrayMinProjector_process(self, value)
	FloatArrayMinProjector_swigregister = _npstat.FloatArrayMinProjector_swigregister
	FloatArrayMinProjector_swigregister(FloatArrayMinProjector)

	class DoubleArrayMinProjector(DoubleDoubleAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [DoubleDoubleAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleArrayMinProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleDoubleAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleArrayMinProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_DoubleArrayMinProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleArrayMinProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.DoubleArrayMinProjector_clear(self)

	def result(self) -> "double":
	return _npstat.DoubleArrayMinProjector_result(self)

	def process(self, value: 'double const &') -> "void":
	return _npstat.DoubleArrayMinProjector_process(self, value)
	DoubleArrayMinProjector_swigregister = _npstat.DoubleArrayMinProjector_swigregister
	DoubleArrayMinProjector_swigregister(DoubleArrayMinProjector)

	class UCharArrayMaxProjector(UCharUCharAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [UCharUCharAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharArrayMaxProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [UCharUCharAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UCharArrayMaxProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_UCharArrayMaxProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UCharArrayMaxProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.UCharArrayMaxProjector_clear(self)

	def result(self) -> "unsigned char":
	return _npstat.UCharArrayMaxProjector_result(self)

	def process(self, value: 'unsigned char const &') -> "void":
	return _npstat.UCharArrayMaxProjector_process(self, value)
	UCharArrayMaxProjector_swigregister = _npstat.UCharArrayMaxProjector_swigregister
	UCharArrayMaxProjector_swigregister(UCharArrayMaxProjector)

	class IntArrayMaxProjector(IntIntAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [IntIntAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntArrayMaxProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [IntIntAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, IntArrayMaxProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_IntArrayMaxProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_IntArrayMaxProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.IntArrayMaxProjector_clear(self)

	def result(self) -> "int":
	return _npstat.IntArrayMaxProjector_result(self)

	def process(self, value: 'int const &') -> "void":
	return _npstat.IntArrayMaxProjector_process(self, value)
	IntArrayMaxProjector_swigregister = _npstat.IntArrayMaxProjector_swigregister
	IntArrayMaxProjector_swigregister(IntArrayMaxProjector)

	class LLongArrayMaxProjector(LLongLLongAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [LLongLLongAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongArrayMaxProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [LLongLLongAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LLongArrayMaxProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_LLongArrayMaxProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_LLongArrayMaxProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.LLongArrayMaxProjector_clear(self)

	def result(self) -> "long long":
	return _npstat.LLongArrayMaxProjector_result(self)

	def process(self, value: 'long long const &') -> "void":
	return _npstat.LLongArrayMaxProjector_process(self, value)
	LLongArrayMaxProjector_swigregister = _npstat.LLongArrayMaxProjector_swigregister
	LLongArrayMaxProjector_swigregister(LLongArrayMaxProjector)

	class FloatArrayMaxProjector(FloatFloatAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [FloatFloatAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatArrayMaxProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [FloatFloatAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatArrayMaxProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_FloatArrayMaxProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatArrayMaxProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.FloatArrayMaxProjector_clear(self)

	def result(self) -> "float":
	return _npstat.FloatArrayMaxProjector_result(self)

	def process(self, value: 'float const &') -> "void":
	return _npstat.FloatArrayMaxProjector_process(self, value)
	FloatArrayMaxProjector_swigregister = _npstat.FloatArrayMaxProjector_swigregister
	FloatArrayMaxProjector_swigregister(FloatArrayMaxProjector)

	class DoubleArrayMaxProjector(DoubleDoubleAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [DoubleDoubleAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleArrayMaxProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleDoubleAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleArrayMaxProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_DoubleArrayMaxProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleArrayMaxProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.DoubleArrayMaxProjector_clear(self)

	def result(self) -> "double":
	return _npstat.DoubleArrayMaxProjector_result(self)

	def process(self, value: 'double const &') -> "void":
	return _npstat.DoubleArrayMaxProjector_process(self, value)
	DoubleArrayMaxProjector_swigregister = _npstat.DoubleArrayMaxProjector_swigregister
	DoubleArrayMaxProjector_swigregister(DoubleArrayMaxProjector)

	class UCharArrayMedianProjector(UCharUCharAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [UCharUCharAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharArrayMedianProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [UCharUCharAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UCharArrayMedianProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_UCharArrayMedianProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UCharArrayMedianProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.UCharArrayMedianProjector_clear(self)

	def process(self, value: 'unsigned char const &') -> "void":
	return _npstat.UCharArrayMedianProjector_process(self, value)

	def result(self) -> "unsigned char":
	return _npstat.UCharArrayMedianProjector_result(self)
	UCharArrayMedianProjector_swigregister = _npstat.UCharArrayMedianProjector_swigregister
	UCharArrayMedianProjector_swigregister(UCharArrayMedianProjector)

	class IntArrayMedianProjector(IntIntAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [IntIntAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntArrayMedianProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [IntIntAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, IntArrayMedianProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_IntArrayMedianProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_IntArrayMedianProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.IntArrayMedianProjector_clear(self)

	def process(self, value: 'int const &') -> "void":
	return _npstat.IntArrayMedianProjector_process(self, value)

	def result(self) -> "int":
	return _npstat.IntArrayMedianProjector_result(self)
	IntArrayMedianProjector_swigregister = _npstat.IntArrayMedianProjector_swigregister
	IntArrayMedianProjector_swigregister(IntArrayMedianProjector)

	class LLongArrayMedianProjector(LLongLLongAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [LLongLLongAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongArrayMedianProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [LLongLLongAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LLongArrayMedianProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_LLongArrayMedianProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_LLongArrayMedianProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.LLongArrayMedianProjector_clear(self)

	def process(self, value: 'long long const &') -> "void":
	return _npstat.LLongArrayMedianProjector_process(self, value)

	def result(self) -> "long long":
	return _npstat.LLongArrayMedianProjector_result(self)
	LLongArrayMedianProjector_swigregister = _npstat.LLongArrayMedianProjector_swigregister
	LLongArrayMedianProjector_swigregister(LLongArrayMedianProjector)

	class FloatArrayMedianProjector(FloatFloatAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [FloatFloatAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatArrayMedianProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [FloatFloatAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatArrayMedianProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_FloatArrayMedianProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatArrayMedianProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.FloatArrayMedianProjector_clear(self)

	def process(self, value: 'float const &') -> "void":
	return _npstat.FloatArrayMedianProjector_process(self, value)

	def result(self) -> "float":
	return _npstat.FloatArrayMedianProjector_result(self)
	FloatArrayMedianProjector_swigregister = _npstat.FloatArrayMedianProjector_swigregister
	FloatArrayMedianProjector_swigregister(FloatArrayMedianProjector)

	class DoubleArrayMedianProjector(DoubleDoubleAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [DoubleDoubleAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleArrayMedianProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleDoubleAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleArrayMedianProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_DoubleArrayMedianProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleArrayMedianProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.DoubleArrayMedianProjector_clear(self)

	def process(self, value: 'double const &') -> "void":
	return _npstat.DoubleArrayMedianProjector_process(self, value)

	def result(self) -> "double":
	return _npstat.DoubleArrayMedianProjector_result(self)
	DoubleArrayMedianProjector_swigregister = _npstat.DoubleArrayMedianProjector_swigregister
	DoubleArrayMedianProjector_swigregister(DoubleArrayMedianProjector)

	class UCharArrayRangeProjector(UCharArrayMedianProjector):
	__swig_setmethods__ = {}
	for _s in [UCharArrayMedianProjector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharArrayRangeProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [UCharArrayMedianProjector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UCharArrayRangeProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_UCharArrayRangeProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UCharArrayRangeProjector
	__del__ = lambda self: None

	def result(self) -> "unsigned char":
	return _npstat.UCharArrayRangeProjector_result(self)
	UCharArrayRangeProjector_swigregister = _npstat.UCharArrayRangeProjector_swigregister
	UCharArrayRangeProjector_swigregister(UCharArrayRangeProjector)

	class IntArrayRangeProjector(IntArrayMedianProjector):
	__swig_setmethods__ = {}
	for _s in [IntArrayMedianProjector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntArrayRangeProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [IntArrayMedianProjector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, IntArrayRangeProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_IntArrayRangeProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_IntArrayRangeProjector
	__del__ = lambda self: None

	def result(self) -> "int":
	return _npstat.IntArrayRangeProjector_result(self)
	IntArrayRangeProjector_swigregister = _npstat.IntArrayRangeProjector_swigregister
	IntArrayRangeProjector_swigregister(IntArrayRangeProjector)

	class LLongArrayRangeProjector(LLongArrayMedianProjector):
	__swig_setmethods__ = {}
	for _s in [LLongArrayMedianProjector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongArrayRangeProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [LLongArrayMedianProjector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LLongArrayRangeProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_LLongArrayRangeProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_LLongArrayRangeProjector
	__del__ = lambda self: None

	def result(self) -> "long long":
	return _npstat.LLongArrayRangeProjector_result(self)
	LLongArrayRangeProjector_swigregister = _npstat.LLongArrayRangeProjector_swigregister
	LLongArrayRangeProjector_swigregister(LLongArrayRangeProjector)

	class FloatArrayRangeProjector(FloatArrayMedianProjector):
	__swig_setmethods__ = {}
	for _s in [FloatArrayMedianProjector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatArrayRangeProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [FloatArrayMedianProjector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatArrayRangeProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_FloatArrayRangeProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatArrayRangeProjector
	__del__ = lambda self: None

	def result(self) -> "float":
	return _npstat.FloatArrayRangeProjector_result(self)
	FloatArrayRangeProjector_swigregister = _npstat.FloatArrayRangeProjector_swigregister
	FloatArrayRangeProjector_swigregister(FloatArrayRangeProjector)

	class DoubleArrayRangeProjector(DoubleArrayMedianProjector):
	__swig_setmethods__ = {}
	for _s in [DoubleArrayMedianProjector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleArrayRangeProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleArrayMedianProjector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleArrayRangeProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_DoubleArrayRangeProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleArrayRangeProjector
	__del__ = lambda self: None

	def result(self) -> "double":
	return _npstat.DoubleArrayRangeProjector_result(self)
	DoubleArrayRangeProjector_swigregister = _npstat.DoubleArrayRangeProjector_swigregister
	DoubleArrayRangeProjector_swigregister(DoubleArrayRangeProjector)

	class DoubleArraySumProjector(DoubleDoubleAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [DoubleDoubleAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleArraySumProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleDoubleAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleArraySumProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_DoubleArraySumProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleArraySumProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.DoubleArraySumProjector_clear(self)

	def result(self) -> "double":
	return _npstat.DoubleArraySumProjector_result(self)

	def process(self, value: 'double const &') -> "void":
	return _npstat.DoubleArraySumProjector_process(self, value)
	DoubleArraySumProjector_swigregister = _npstat.DoubleArraySumProjector_swigregister
	DoubleArraySumProjector_swigregister(DoubleArraySumProjector)

	class FloatArraySumProjector(FloatDoubleAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [FloatDoubleAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatArraySumProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [FloatDoubleAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatArraySumProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_FloatArraySumProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatArraySumProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.FloatArraySumProjector_clear(self)

	def result(self) -> "double":
	return _npstat.FloatArraySumProjector_result(self)

	def process(self, value: 'float const &') -> "void":
	return _npstat.FloatArraySumProjector_process(self, value)
	FloatArraySumProjector_swigregister = _npstat.FloatArraySumProjector_swigregister
	FloatArraySumProjector_swigregister(FloatArraySumProjector)

	class IntArraySumProjector(IntDoubleAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [IntDoubleAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntArraySumProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [IntDoubleAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, IntArraySumProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_IntArraySumProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_IntArraySumProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.IntArraySumProjector_clear(self)

	def result(self) -> "double":
	return _npstat.IntArraySumProjector_result(self)

	def process(self, value: 'int const &') -> "void":
	return _npstat.IntArraySumProjector_process(self, value)
	IntArraySumProjector_swigregister = _npstat.IntArraySumProjector_swigregister
	IntArraySumProjector_swigregister(IntArraySumProjector)

	class LLongArraySumProjector(LLongDoubleAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [LLongDoubleAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongArraySumProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [LLongDoubleAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LLongArraySumProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_LLongArraySumProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_LLongArraySumProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.LLongArraySumProjector_clear(self)

	def result(self) -> "double":
	return _npstat.LLongArraySumProjector_result(self)

	def process(self, value: 'long long const &') -> "void":
	return _npstat.LLongArraySumProjector_process(self, value)
	LLongArraySumProjector_swigregister = _npstat.LLongArraySumProjector_swigregister
	LLongArraySumProjector_swigregister(LLongArraySumProjector)

	class UCharArraySumProjector(UCharDoubleAbsVisitor):
	__swig_setmethods__ = {}
	for _s in [UCharDoubleAbsVisitor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharArraySumProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [UCharDoubleAbsVisitor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UCharArraySumProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_UCharArraySumProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UCharArraySumProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.UCharArraySumProjector_clear(self)

	def result(self) -> "double":
	return _npstat.UCharArraySumProjector_result(self)

	def process(self, value: 'unsigned char const &') -> "void":
	return _npstat.UCharArraySumProjector_process(self, value)
	UCharArraySumProjector_swigregister = _npstat.UCharArraySumProjector_swigregister
	UCharArraySumProjector_swigregister(UCharArraySumProjector)

	class DoubleArrayMeanProjector(DoubleArraySumProjector):
	__swig_setmethods__ = {}
	for _s in [DoubleArraySumProjector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleArrayMeanProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleArraySumProjector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleArrayMeanProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_DoubleArrayMeanProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleArrayMeanProjector
	__del__ = lambda self: None

	def result(self) -> "double":
	return _npstat.DoubleArrayMeanProjector_result(self)
	DoubleArrayMeanProjector_swigregister = _npstat.DoubleArrayMeanProjector_swigregister
	DoubleArrayMeanProjector_swigregister(DoubleArrayMeanProjector)

	class FloatArrayMeanProjector(FloatArraySumProjector):
	__swig_setmethods__ = {}
	for _s in [FloatArraySumProjector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatArrayMeanProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [FloatArraySumProjector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatArrayMeanProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_FloatArrayMeanProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_FloatArrayMeanProjector
	__del__ = lambda self: None

	def result(self) -> "double":
	return _npstat.FloatArrayMeanProjector_result(self)
	FloatArrayMeanProjector_swigregister = _npstat.FloatArrayMeanProjector_swigregister
	FloatArrayMeanProjector_swigregister(FloatArrayMeanProjector)

	class IntArrayMeanProjector(IntArraySumProjector):
	__swig_setmethods__ = {}
	for _s in [IntArraySumProjector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntArrayMeanProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [IntArraySumProjector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, IntArrayMeanProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_IntArrayMeanProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_IntArrayMeanProjector
	__del__ = lambda self: None

	def result(self) -> "double":
	return _npstat.IntArrayMeanProjector_result(self)
	IntArrayMeanProjector_swigregister = _npstat.IntArrayMeanProjector_swigregister
	IntArrayMeanProjector_swigregister(IntArrayMeanProjector)

	class LLongArrayMeanProjector(LLongArraySumProjector):
	__swig_setmethods__ = {}
	for _s in [LLongArraySumProjector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongArrayMeanProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [LLongArraySumProjector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LLongArrayMeanProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_LLongArrayMeanProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_LLongArrayMeanProjector
	__del__ = lambda self: None

	def result(self) -> "double":
	return _npstat.LLongArrayMeanProjector_result(self)
	LLongArrayMeanProjector_swigregister = _npstat.LLongArrayMeanProjector_swigregister
	LLongArrayMeanProjector_swigregister(LLongArrayMeanProjector)

	class UCharArrayMeanProjector(UCharArraySumProjector):
	__swig_setmethods__ = {}
	for _s in [UCharArraySumProjector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharArrayMeanProjector, name, value)
	__swig_getmethods__ = {}
	for _s in [UCharArraySumProjector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, UCharArrayMeanProjector, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_UCharArrayMeanProjector()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_UCharArrayMeanProjector
	__del__ = lambda self: None

	def result(self) -> "double":
	return _npstat.UCharArrayMeanProjector_result(self)
	UCharArrayMeanProjector_swigregister = _npstat.UCharArrayMeanProjector_swigregister
	UCharArrayMeanProjector_swigregister(UCharArrayMeanProjector)

	class KDE1DHOSymbetaKernel(AbsKDE1DKernel):
	__swig_setmethods__ = {}
	for _s in [AbsKDE1DKernel]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, KDE1DHOSymbetaKernel, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsKDE1DKernel]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, KDE1DHOSymbetaKernel, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_KDE1DHOSymbetaKernel(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::KDE1DHOSymbetaKernel *":
	return _npstat.KDE1DHOSymbetaKernel_clone(self)
	__swig_destroy__ = _npstat.delete_KDE1DHOSymbetaKernel
	__del__ = lambda self: None

	def power(self) -> "int":
	return _npstat.KDE1DHOSymbetaKernel_power(self)

	def filterDegree(self) -> "double":
	return _npstat.KDE1DHOSymbetaKernel_filterDegree(self)

	def weight(self, x: 'double const') -> "double":
	return _npstat.KDE1DHOSymbetaKernel_weight(self, x)

	def xmin(self) -> "double":
	return _npstat.KDE1DHOSymbetaKernel_xmin(self)

	def xmax(self) -> "double":
	return _npstat.KDE1DHOSymbetaKernel_xmax(self)

	def __call__(self, x: 'double const') -> "double":
	return _npstat.KDE1DHOSymbetaKernel___call__(self, x)
	KDE1DHOSymbetaKernel_swigregister = _npstat.KDE1DHOSymbetaKernel_swigregister
	KDE1DHOSymbetaKernel_swigregister(KDE1DHOSymbetaKernel)

	class RatioOfNormals(AbsDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, RatioOfNormals, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, RatioOfNormals, name)
	__repr__ = _swig_repr

	def __init__(self, mu1: 'double', s1: 'double', mu2: 'double', s2: 'double', rho: 'double'):
	this = _npstat.new_RatioOfNormals(mu1, s1, mu2, s2, rho)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_RatioOfNormals
	__del__ = lambda self: None

	def clone(self) -> "npstat::RatioOfNormals *":
	return _npstat.RatioOfNormals_clone(self)

	def density(self, x: 'double') -> "double":
	return _npstat.RatioOfNormals_density(self, x)

	def cdf(self, x: 'double') -> "double":
	return _npstat.RatioOfNormals_cdf(self, x)

	def exceedance(self, x: 'double') -> "double":
	return _npstat.RatioOfNormals_exceedance(self, x)

	def quantile(self, x: 'double') -> "double":
	return _npstat.RatioOfNormals_quantile(self, x)

	def classId(self) -> "gs::ClassId":
	return _npstat.RatioOfNormals_classId(self)

	def write(self, arg2: 'ostream') -> "bool":
	return _npstat.RatioOfNormals_write(self, arg2)
	if _newclass:
	classname = staticmethod(_npstat.RatioOfNormals_classname)
	else:
	classname = _npstat.RatioOfNormals_classname
	if _newclass:
	version = staticmethod(_npstat.RatioOfNormals_version)
	else:
	version = _npstat.RatioOfNormals_version
	if _newclass:
	read = staticmethod(_npstat.RatioOfNormals_read)
	else:
	read = _npstat.RatioOfNormals_read
	RatioOfNormals_swigregister = _npstat.RatioOfNormals_swigregister
	RatioOfNormals_swigregister(RatioOfNormals)

	def RatioOfNormals_classname() -> "char const *":
	return _npstat.RatioOfNormals_classname()
	RatioOfNormals_classname = _npstat.RatioOfNormals_classname

	def RatioOfNormals_version() -> "unsigned int":
	return _npstat.RatioOfNormals_version()
	RatioOfNormals_version = _npstat.RatioOfNormals_version

	def RatioOfNormals_read(id: 'ClassId', arg3: 'istream') -> "npstat::RatioOfNormals *":
	return _npstat.RatioOfNormals_read(id, arg3)
	RatioOfNormals_read = _npstat.RatioOfNormals_read

	class AbsMarginalSmootherBase(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsMarginalSmootherBase, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, AbsMarginalSmootherBase, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsMarginalSmootherBase
	__del__ = lambda self: None

	def setAxisLabel(self, axisLabel: 'char const *') -> "void":
	return _npstat.AbsMarginalSmootherBase_setAxisLabel(self, axisLabel)

	def nBins(self) -> "unsigned int":
	return _npstat.AbsMarginalSmootherBase_nBins(self)

	def xMin(self) -> "double":
	return _npstat.AbsMarginalSmootherBase_xMin(self)

	def xMax(self) -> "double":
	return _npstat.AbsMarginalSmootherBase_xMax(self)

	def binWidth(self) -> "double":
	return _npstat.AbsMarginalSmootherBase_binWidth(self)

	def getAxisLabel(self) -> "std::string const &":
	return _npstat.AbsMarginalSmootherBase_getAxisLabel(self)

	def lastBandwidth(self) -> "double":
	return _npstat.AbsMarginalSmootherBase_lastBandwidth(self)

	def setArchive(self, ar: 'AbsArchive', category: 'char const *'=None) -> "void":
	return _npstat.AbsMarginalSmootherBase_setArchive(self, ar, category)

	def unsetArchive(self) -> "void":
	return _npstat.AbsMarginalSmootherBase_unsetArchive(self)

	- def smooth(self, inputPoints: 'DoubleVector') -> "npstat::HistoND< double >":
	+ def smooth(self, inputPoints: 'DoubleVector') -> "npstat::HistoND< double,npstat::HistoAxis > *":
	return _npstat.AbsMarginalSmootherBase_smooth(self, inputPoints)

	- def weightedSmooth(self, inputPoints: 'DoubleDoublePairVector') -> "npstat::HistoND< double >":
	+ def weightedSmooth(self, inputPoints: 'DoubleDoublePairVector') -> "npstat::HistoND< double,npstat::HistoAxis > *":
	return _npstat.AbsMarginalSmootherBase_weightedSmooth(self, inputPoints)

	- def smoothArch(self, inputPoints: 'DoubleVector', uniqueId: 'unsigned long', dimNumber: 'unsigned int') -> "npstat::HistoND< double >":
	+ def smoothArch(self, inputPoints: 'DoubleVector', uniqueId: 'unsigned long', dimNumber: 'unsigned int') -> "npstat::HistoND< double,npstat::HistoAxis > *":
	return _npstat.AbsMarginalSmootherBase_smoothArch(self, inputPoints, uniqueId, dimNumber)

	- def weightedSmoothArch(self, inputPoints: 'DoubleDoublePairVector', uniqueId: 'unsigned long', dimNumber: 'unsigned int') -> "npstat::HistoND< double >":
	+ def weightedSmoothArch(self, inputPoints: 'DoubleDoublePairVector', uniqueId: 'unsigned long', dimNumber: 'unsigned int') -> "npstat::HistoND< double,npstat::HistoAxis > *":
	return _npstat.AbsMarginalSmootherBase_weightedSmoothArch(self, inputPoints, uniqueId, dimNumber)
	AbsMarginalSmootherBase_swigregister = _npstat.AbsMarginalSmootherBase_swigregister
	AbsMarginalSmootherBase_swigregister(AbsMarginalSmootherBase)

	class ConstantBandwidthSmoother1D(AbsMarginalSmootherBase, AbsPolyFilter1D):
	__swig_setmethods__ = {}
	for _s in [AbsMarginalSmootherBase, AbsPolyFilter1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ConstantBandwidthSmoother1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsMarginalSmootherBase, AbsPolyFilter1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ConstantBandwidthSmoother1D, name)
	__repr__ = _swig_repr

	def __init__(self, nbins: 'unsigned int', xmin: 'double', xmax: 'double', symbetaPower: 'int', kernelOrder: 'unsigned int', bandwidth: 'double'=0.0, bwFactor: 'double'=1.0, mirrorData: 'bool'=True, label: 'char const *'=None):
	this = _npstat.new_ConstantBandwidthSmoother1D(nbins, xmin, xmax, symbetaPower, kernelOrder, bandwidth, bwFactor, mirrorData, label)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ConstantBandwidthSmoother1D
	__del__ = lambda self: None

	def symbetaPower(self) -> "int":
	return _npstat.ConstantBandwidthSmoother1D_symbetaPower(self)

	def kernelOrder(self) -> "unsigned int":
	return _npstat.ConstantBandwidthSmoother1D_kernelOrder(self)

	def fixedBandwidth(self) -> "double":
	return _npstat.ConstantBandwidthSmoother1D_fixedBandwidth(self)

	def bwFactor(self) -> "double":
	return _npstat.ConstantBandwidthSmoother1D_bwFactor(self)

	def mirrorsData(self) -> "bool":
	return _npstat.ConstantBandwidthSmoother1D_mirrorsData(self)

	def dataLen(self) -> "unsigned int":
	return _npstat.ConstantBandwidthSmoother1D_dataLen(self)

	def selfContribution(self, arg2: 'unsigned int') -> "double":
	return _npstat.ConstantBandwidthSmoother1D_selfContribution(self, arg2)
	ConstantBandwidthSmoother1D_swigregister = _npstat.ConstantBandwidthSmoother1D_swigregister
	ConstantBandwidthSmoother1D_swigregister(ConstantBandwidthSmoother1D)

	class CompositeDistribution1D(AbsDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, CompositeDistribution1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, CompositeDistribution1D, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_CompositeDistribution1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_CompositeDistribution1D
	__del__ = lambda self: None

	def density(self, x: 'double const') -> "double":
	return _npstat.CompositeDistribution1D_density(self, x)

	def cdf(self, x: 'double const') -> "double":
	return _npstat.CompositeDistribution1D_cdf(self, x)

	def exceedance(self, x: 'double const') -> "double":
	return _npstat.CompositeDistribution1D_exceedance(self, x)

	def quantile(self, x: 'double const') -> "double":
	return _npstat.CompositeDistribution1D_quantile(self, x)

	def clone(self) -> "npstat::CompositeDistribution1D *":
	return _npstat.CompositeDistribution1D_clone(self)

	def G(self) -> "npstat::AbsDistribution1D const &":
	return _npstat.CompositeDistribution1D_G(self)

	def H(self) -> "npstat::AbsDistribution1D const &":
	return _npstat.CompositeDistribution1D_H(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.CompositeDistribution1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.CompositeDistribution1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.CompositeDistribution1D_classname)
	else:
	classname = _npstat.CompositeDistribution1D_classname
	if _newclass:
	version = staticmethod(_npstat.CompositeDistribution1D_version)
	else:
	version = _npstat.CompositeDistribution1D_version
	if _newclass:
	read = staticmethod(_npstat.CompositeDistribution1D_read)
	else:
	read = _npstat.CompositeDistribution1D_read
	CompositeDistribution1D_swigregister = _npstat.CompositeDistribution1D_swigregister
	CompositeDistribution1D_swigregister(CompositeDistribution1D)

	def CompositeDistribution1D_classname() -> "char const *":
	return _npstat.CompositeDistribution1D_classname()
	CompositeDistribution1D_classname = _npstat.CompositeDistribution1D_classname

	def CompositeDistribution1D_version() -> "unsigned int":
	return _npstat.CompositeDistribution1D_version()
	CompositeDistribution1D_version = _npstat.CompositeDistribution1D_version

	def CompositeDistribution1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::CompositeDistribution1D *":
	return _npstat.CompositeDistribution1D_read(id, arg3)
	CompositeDistribution1D_read = _npstat.CompositeDistribution1D_read

	class DoubleKDE1D(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleKDE1D, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleKDE1D, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_DoubleKDE1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DoubleKDE1D
	__del__ = lambda self: None

	def kernel(self) -> "npstat::AbsKDE1DKernel const &":
	return _npstat.DoubleKDE1D_kernel(self)

	def coords(self) -> "std::vector< double,std::allocator< double > > const &":
	return _npstat.DoubleKDE1D_coords(self)

	def nCoords(self) -> "unsigned long":
	return _npstat.DoubleKDE1D_nCoords(self)

	def minCoordinate(self) -> "double":
	return _npstat.DoubleKDE1D_minCoordinate(self)

	def maxCoordinate(self) -> "double":
	return _npstat.DoubleKDE1D_maxCoordinate(self)

	def density(self, x: 'double const', bw: 'double const') -> "double":
	return _npstat.DoubleKDE1D_density(self, x, bw)

	def densityFunctor(self, bandwidth: 'double const') -> "npstat::KDE1DFunctorHelper< double >":
	return _npstat.DoubleKDE1D_densityFunctor(self, bandwidth)

	def rlcvFunctor(self, plcvAlpha: 'double const') -> "npstat::KDE1DRLCVFunctorHelper< double >":
	return _npstat.DoubleKDE1D_rlcvFunctor(self, plcvAlpha)

	def lscvFunctor(self, xmin: 'double const', xmax: 'double const', nIntegIntervals: 'unsigned int const', nIntegPoints: 'unsigned int const') -> "npstat::KDE1DLSCVFunctorHelper< double >":
	return _npstat.DoubleKDE1D_lscvFunctor(self, xmin, xmax, nIntegIntervals, nIntegPoints)

	def integratedSquaredError(self, distro: 'AbsDistribution1D', nIntegIntervals: 'unsigned int const', nIntegPoints: 'unsigned int const', bandwidth: 'double const') -> "double":
	return _npstat.DoubleKDE1D_integratedSquaredError(self, distro, nIntegIntervals, nIntegPoints, bandwidth)

	def rlcv(self, bw: 'double const', plcvAlpha: 'double const') -> "double":
	return _npstat.DoubleKDE1D_rlcv(self, bw, plcvAlpha)

	def lscv(self, bw: 'double const', xmin: 'double const', xmax: 'double const', nIntegIntervals: 'unsigned int const', nIntegPoints: 'unsigned int const') -> "double":
	return _npstat.DoubleKDE1D_lscv(self, bw, xmin, xmax, nIntegIntervals, nIntegPoints)
	DoubleKDE1D_swigregister = _npstat.DoubleKDE1D_swigregister
	DoubleKDE1D_swigregister(DoubleKDE1D)

	class WeightedStatAccumulatorPair(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, WeightedStatAccumulatorPair, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, WeightedStatAccumulatorPair, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_WeightedStatAccumulatorPair()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def first(self) -> "npstat::WeightedStatAccumulator const &":
	return _npstat.WeightedStatAccumulatorPair_first(self)

	def second(self) -> "npstat::WeightedStatAccumulator const &":
	return _npstat.WeightedStatAccumulatorPair_second(self)

	def crossSumsq(self) -> "long double":
	return _npstat.WeightedStatAccumulatorPair_crossSumsq(self)

	def count(self) -> "double":
	return _npstat.WeightedStatAccumulatorPair_count(self)

	def ncalls(self) -> "unsigned long":
	return _npstat.WeightedStatAccumulatorPair_ncalls(self)

	def nfills(self) -> "unsigned long":
	return _npstat.WeightedStatAccumulatorPair_nfills(self)

	def cov(self) -> "double":
	return _npstat.WeightedStatAccumulatorPair_cov(self)

	def corr(self) -> "double":
	return _npstat.WeightedStatAccumulatorPair_corr(self)

	def accumulate(self, *args) -> "void":
	return _npstat.WeightedStatAccumulatorPair_accumulate(self, *args)

	def reset(self) -> "void":
	return _npstat.WeightedStatAccumulatorPair_reset(self)

	def __iadd__(self, r: 'WeightedStatAccumulatorPair') -> "npstat::WeightedStatAccumulatorPair &":
	return _npstat.WeightedStatAccumulatorPair___iadd__(self, r)

	def scaleWeights(self, r: 'double const') -> "npstat::WeightedStatAccumulatorPair &":
	return _npstat.WeightedStatAccumulatorPair_scaleWeights(self, r)

	def __eq__(self, r: 'WeightedStatAccumulatorPair') -> "bool":
	return _npstat.WeightedStatAccumulatorPair___eq__(self, r)

	def __ne__(self, r: 'WeightedStatAccumulatorPair') -> "bool":
	return _npstat.WeightedStatAccumulatorPair___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.WeightedStatAccumulatorPair_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.WeightedStatAccumulatorPair_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.WeightedStatAccumulatorPair_classname)
	else:
	classname = _npstat.WeightedStatAccumulatorPair_classname
	if _newclass:
	version = staticmethod(_npstat.WeightedStatAccumulatorPair_version)
	else:
	version = _npstat.WeightedStatAccumulatorPair_version
	if _newclass:
	restore = staticmethod(_npstat.WeightedStatAccumulatorPair_restore)
	else:
	restore = _npstat.WeightedStatAccumulatorPair_restore
	__swig_destroy__ = _npstat.delete_WeightedStatAccumulatorPair
	__del__ = lambda self: None
	WeightedStatAccumulatorPair_swigregister = _npstat.WeightedStatAccumulatorPair_swigregister
	WeightedStatAccumulatorPair_swigregister(WeightedStatAccumulatorPair)

	def WeightedStatAccumulatorPair_classname() -> "char const *":
	return _npstat.WeightedStatAccumulatorPair_classname()
	WeightedStatAccumulatorPair_classname = _npstat.WeightedStatAccumulatorPair_classname

	def WeightedStatAccumulatorPair_version() -> "unsigned int":
	return _npstat.WeightedStatAccumulatorPair_version()
	WeightedStatAccumulatorPair_version = _npstat.WeightedStatAccumulatorPair_version

	def WeightedStatAccumulatorPair_restore(id: 'ClassId', arg3: 'istream', acc: 'WeightedStatAccumulatorPair') -> "void":
	return _npstat.WeightedStatAccumulatorPair_restore(id, arg3, acc)
	WeightedStatAccumulatorPair_restore = _npstat.WeightedStatAccumulatorPair_restore

	class LeftCensoredDistribution(AbsDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LeftCensoredDistribution, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LeftCensoredDistribution, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_LeftCensoredDistribution(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::LeftCensoredDistribution *":
	return _npstat.LeftCensoredDistribution_clone(self)
	__swig_destroy__ = _npstat.delete_LeftCensoredDistribution
	__del__ = lambda self: None

	def visible(self) -> "npstat::AbsDistribution1D const &":
	return _npstat.LeftCensoredDistribution_visible(self)

	def visibleFraction(self) -> "double":
	return _npstat.LeftCensoredDistribution_visibleFraction(self)

	def effectiveInfinity(self) -> "double":
	return _npstat.LeftCensoredDistribution_effectiveInfinity(self)

	def density(self, x: 'double') -> "double":
	return _npstat.LeftCensoredDistribution_density(self, x)

	def cdf(self, x: 'double') -> "double":
	return _npstat.LeftCensoredDistribution_cdf(self, x)

	def exceedance(self, x: 'double') -> "double":
	return _npstat.LeftCensoredDistribution_exceedance(self, x)

	def quantile(self, x: 'double') -> "double":
	return _npstat.LeftCensoredDistribution_quantile(self, x)

	def classId(self) -> "gs::ClassId":
	return _npstat.LeftCensoredDistribution_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.LeftCensoredDistribution_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.LeftCensoredDistribution_classname)
	else:
	classname = _npstat.LeftCensoredDistribution_classname
	if _newclass:
	version = staticmethod(_npstat.LeftCensoredDistribution_version)
	else:
	version = _npstat.LeftCensoredDistribution_version
	if _newclass:
	read = staticmethod(_npstat.LeftCensoredDistribution_read)
	else:
	read = _npstat.LeftCensoredDistribution_read
	LeftCensoredDistribution_swigregister = _npstat.LeftCensoredDistribution_swigregister
	LeftCensoredDistribution_swigregister(LeftCensoredDistribution)

	def LeftCensoredDistribution_classname() -> "char const *":
	return _npstat.LeftCensoredDistribution_classname()
	LeftCensoredDistribution_classname = _npstat.LeftCensoredDistribution_classname

	def LeftCensoredDistribution_version() -> "unsigned int":
	return _npstat.LeftCensoredDistribution_version()
	LeftCensoredDistribution_version = _npstat.LeftCensoredDistribution_version

	def LeftCensoredDistribution_read(id: 'ClassId', arg3: 'istream') -> "npstat::LeftCensoredDistribution *":
	return _npstat.LeftCensoredDistribution_read(id, arg3)
	LeftCensoredDistribution_read = _npstat.LeftCensoredDistribution_read


	def multinomialCovariance1D(fcn: 'AbsDistribution1D', sampleSize: 'double', nbins: 'unsigned int', xmin: 'double', xmax: 'double', nIntegrationPoints: 'unsigned int'=0) -> "npstat::Matrix< double,16 >":
	return _npstat.multinomialCovariance1D(fcn, sampleSize, nbins, xmin, xmax, nIntegrationPoints)
	multinomialCovariance1D = _npstat.multinomialCovariance1D
	class DistributionMix1D(AbsDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DistributionMix1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DistributionMix1D, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_DistributionMix1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::DistributionMix1D *":
	return _npstat.DistributionMix1D_clone(self)
	__swig_destroy__ = _npstat.delete_DistributionMix1D
	__del__ = lambda self: None

	def add(self, distro: 'AbsDistribution1D', weight: 'double') -> "npstat::DistributionMix1D &":
	return _npstat.DistributionMix1D_add(self, distro, weight)

	def setWeights(self, weights: 'double const *', nWeights: 'unsigned int') -> "void":
	return _npstat.DistributionMix1D_setWeights(self, weights, nWeights)

	def nComponents(self) -> "unsigned int":
	return _npstat.DistributionMix1D_nComponents(self)

	def getComponent(self, n: 'unsigned int const') -> "npstat::AbsDistribution1D const &":
	return _npstat.DistributionMix1D_getComponent(self, n)

	def getWeight(self, n: 'unsigned int') -> "double":
	return _npstat.DistributionMix1D_getWeight(self, n)

	def density(self, x: 'double') -> "double":
	return _npstat.DistributionMix1D_density(self, x)

	def cdf(self, x: 'double') -> "double":
	return _npstat.DistributionMix1D_cdf(self, x)

	def exceedance(self, x: 'double') -> "double":
	return _npstat.DistributionMix1D_exceedance(self, x)

	def quantile(self, x: 'double') -> "double":
	return _npstat.DistributionMix1D_quantile(self, x)

	def classId(self) -> "gs::ClassId":
	return _npstat.DistributionMix1D_classId(self)

	def write(self, arg2: 'ostream') -> "bool":
	return _npstat.DistributionMix1D_write(self, arg2)
	if _newclass:
	classname = staticmethod(_npstat.DistributionMix1D_classname)
	else:
	classname = _npstat.DistributionMix1D_classname
	if _newclass:
	version = staticmethod(_npstat.DistributionMix1D_version)
	else:
	version = _npstat.DistributionMix1D_version
	if _newclass:
	read = staticmethod(_npstat.DistributionMix1D_read)
	else:
	read = _npstat.DistributionMix1D_read
	DistributionMix1D_swigregister = _npstat.DistributionMix1D_swigregister
	DistributionMix1D_swigregister(DistributionMix1D)

	def DistributionMix1D_classname() -> "char const *":
	return _npstat.DistributionMix1D_classname()
	DistributionMix1D_classname = _npstat.DistributionMix1D_classname

	def DistributionMix1D_version() -> "unsigned int":
	return _npstat.DistributionMix1D_version()
	DistributionMix1D_version = _npstat.DistributionMix1D_version

	def DistributionMix1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::DistributionMix1D *":
	return _npstat.DistributionMix1D_read(id, arg3)
	DistributionMix1D_read = _npstat.DistributionMix1D_read

	class DoubleHistoNDFunctor(StorableMultivariateFunctor):
	__swig_setmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleHistoNDFunctor, name, value)
	__swig_getmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleHistoNDFunctor, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleHistoNDFunctor
	__del__ = lambda self: None

	def minDim(self) -> "unsigned int":
	return _npstat.DoubleHistoNDFunctor_minDim(self)

	def __call__(self, point: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.DoubleHistoNDFunctor___call__(self, point, dim)

	def interpolationDegree(self) -> "unsigned int":
	return _npstat.DoubleHistoNDFunctor_interpolationDegree(self)

	def setInterpolationDegree(self, deg: 'unsigned int const') -> "void":
	return _npstat.DoubleHistoNDFunctor_setInterpolationDegree(self, deg)

	def interpolator(self, *args) -> "npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis >::Table const &":
	return _npstat.DoubleHistoNDFunctor_interpolator(self, *args)

	def table(self, *args) -> "npstat::ArrayND< double > const &":
	return _npstat.DoubleHistoNDFunctor_table(self, *args)

	def setConverter(self, conv: 'DoubleSame') -> "void":
	return _npstat.DoubleHistoNDFunctor_setConverter(self, conv)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleHistoNDFunctor_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleHistoNDFunctor_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleHistoNDFunctor_classname)
	else:
	classname = _npstat.DoubleHistoNDFunctor_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleHistoNDFunctor_version)
	else:
	version = _npstat.DoubleHistoNDFunctor_version
	if _newclass:
	read = staticmethod(_npstat.DoubleHistoNDFunctor_read)
	else:
	read = _npstat.DoubleHistoNDFunctor_read
	DoubleHistoNDFunctor_swigregister = _npstat.DoubleHistoNDFunctor_swigregister
	DoubleHistoNDFunctor_swigregister(DoubleHistoNDFunctor)

	def DoubleHistoNDFunctor_classname() -> "char const *":
	return _npstat.DoubleHistoNDFunctor_classname()
	DoubleHistoNDFunctor_classname = _npstat.DoubleHistoNDFunctor_classname

	def DoubleHistoNDFunctor_version() -> "unsigned int":
	return _npstat.DoubleHistoNDFunctor_version()
	DoubleHistoNDFunctor_version = _npstat.DoubleHistoNDFunctor_version

	def DoubleHistoNDFunctor_read(id: 'ClassId', arg3: 'istream') -> "npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > *":
	return _npstat.DoubleHistoNDFunctor_read(id, arg3)
	DoubleHistoNDFunctor_read = _npstat.DoubleHistoNDFunctor_read

	class DoubleUAHistoNDFunctor(StorableMultivariateFunctor):
	__swig_setmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleUAHistoNDFunctor, name, value)
	__swig_getmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleUAHistoNDFunctor, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleUAHistoNDFunctor
	__del__ = lambda self: None

	def minDim(self) -> "unsigned int":
	return _npstat.DoubleUAHistoNDFunctor_minDim(self)

	def __call__(self, point: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.DoubleUAHistoNDFunctor___call__(self, point, dim)

	def interpolationDegree(self) -> "unsigned int":
	return _npstat.DoubleUAHistoNDFunctor_interpolationDegree(self)

	def setInterpolationDegree(self, deg: 'unsigned int const') -> "void":
	return _npstat.DoubleUAHistoNDFunctor_setInterpolationDegree(self, deg)

	def interpolator(self, *args) -> "npstat::StorableHistoNDFunctor< double,npstat::HistoAxis >::Table const &":
	return _npstat.DoubleUAHistoNDFunctor_interpolator(self, *args)

	def table(self, *args) -> "npstat::ArrayND< double > const &":
	return _npstat.DoubleUAHistoNDFunctor_table(self, *args)

	def setConverter(self, conv: 'DoubleSame') -> "void":
	return _npstat.DoubleUAHistoNDFunctor_setConverter(self, conv)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleUAHistoNDFunctor_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleUAHistoNDFunctor_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleUAHistoNDFunctor_classname)
	else:
	classname = _npstat.DoubleUAHistoNDFunctor_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleUAHistoNDFunctor_version)
	else:
	version = _npstat.DoubleUAHistoNDFunctor_version
	if _newclass:
	read = staticmethod(_npstat.DoubleUAHistoNDFunctor_read)
	else:
	read = _npstat.DoubleUAHistoNDFunctor_read
	DoubleUAHistoNDFunctor_swigregister = _npstat.DoubleUAHistoNDFunctor_swigregister
	DoubleUAHistoNDFunctor_swigregister(DoubleUAHistoNDFunctor)

	def DoubleUAHistoNDFunctor_classname() -> "char const *":
	return _npstat.DoubleUAHistoNDFunctor_classname()
	DoubleUAHistoNDFunctor_classname = _npstat.DoubleUAHistoNDFunctor_classname

	def DoubleUAHistoNDFunctor_version() -> "unsigned int":
	return _npstat.DoubleUAHistoNDFunctor_version()
	DoubleUAHistoNDFunctor_version = _npstat.DoubleUAHistoNDFunctor_version

	def DoubleUAHistoNDFunctor_read(id: 'ClassId', arg3: 'istream') -> "npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > *":
	return _npstat.DoubleUAHistoNDFunctor_read(id, arg3)
	DoubleUAHistoNDFunctor_read = _npstat.DoubleUAHistoNDFunctor_read

	class DoubleNUHistoNDFunctor(StorableMultivariateFunctor):
	__swig_setmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleNUHistoNDFunctor, name, value)
	__swig_getmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleNUHistoNDFunctor, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleNUHistoNDFunctor
	__del__ = lambda self: None

	def minDim(self) -> "unsigned int":
	return _npstat.DoubleNUHistoNDFunctor_minDim(self)

	def __call__(self, point: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.DoubleNUHistoNDFunctor___call__(self, point, dim)

	def interpolationDegree(self) -> "unsigned int":
	return _npstat.DoubleNUHistoNDFunctor_interpolationDegree(self)

	def setInterpolationDegree(self, deg: 'unsigned int const') -> "void":
	return _npstat.DoubleNUHistoNDFunctor_setInterpolationDegree(self, deg)

	def interpolator(self, *args) -> "npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis >::Table const &":
	return _npstat.DoubleNUHistoNDFunctor_interpolator(self, *args)

	def table(self, *args) -> "npstat::ArrayND< double > const &":
	return _npstat.DoubleNUHistoNDFunctor_table(self, *args)

	def setConverter(self, conv: 'DoubleSame') -> "void":
	return _npstat.DoubleNUHistoNDFunctor_setConverter(self, conv)

	def classId(self) -> "gs::ClassId":
	return _npstat.DoubleNUHistoNDFunctor_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.DoubleNUHistoNDFunctor_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.DoubleNUHistoNDFunctor_classname)
	else:
	classname = _npstat.DoubleNUHistoNDFunctor_classname
	if _newclass:
	version = staticmethod(_npstat.DoubleNUHistoNDFunctor_version)
	else:
	version = _npstat.DoubleNUHistoNDFunctor_version
	if _newclass:
	read = staticmethod(_npstat.DoubleNUHistoNDFunctor_read)
	else:
	read = _npstat.DoubleNUHistoNDFunctor_read
	DoubleNUHistoNDFunctor_swigregister = _npstat.DoubleNUHistoNDFunctor_swigregister
	DoubleNUHistoNDFunctor_swigregister(DoubleNUHistoNDFunctor)

	def DoubleNUHistoNDFunctor_classname() -> "char const *":
	return _npstat.DoubleNUHistoNDFunctor_classname()
	DoubleNUHistoNDFunctor_classname = _npstat.DoubleNUHistoNDFunctor_classname

	def DoubleNUHistoNDFunctor_version() -> "unsigned int":
	return _npstat.DoubleNUHistoNDFunctor_version()
	DoubleNUHistoNDFunctor_version = _npstat.DoubleNUHistoNDFunctor_version

	def DoubleNUHistoNDFunctor_read(id: 'ClassId', arg3: 'istream') -> "npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > *":
	return _npstat.DoubleNUHistoNDFunctor_read(id, arg3)
	DoubleNUHistoNDFunctor_read = _npstat.DoubleNUHistoNDFunctor_read

	class FloatHistoNDFunctor(StorableMultivariateFunctor):
	__swig_setmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatHistoNDFunctor, name, value)
	__swig_getmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatHistoNDFunctor, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatHistoNDFunctor
	__del__ = lambda self: None

	def minDim(self) -> "unsigned int":
	return _npstat.FloatHistoNDFunctor_minDim(self)

	def __call__(self, point: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.FloatHistoNDFunctor___call__(self, point, dim)

	def interpolationDegree(self) -> "unsigned int":
	return _npstat.FloatHistoNDFunctor_interpolationDegree(self)

	def setInterpolationDegree(self, deg: 'unsigned int const') -> "void":
	return _npstat.FloatHistoNDFunctor_setInterpolationDegree(self, deg)

	def interpolator(self, *args) -> "npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis >::Table const &":
	return _npstat.FloatHistoNDFunctor_interpolator(self, *args)

	def table(self, *args) -> "npstat::ArrayND< float > const &":
	return _npstat.FloatHistoNDFunctor_table(self, *args)

	def setConverter(self, conv: 'FloatSame') -> "void":
	return _npstat.FloatHistoNDFunctor_setConverter(self, conv)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatHistoNDFunctor_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatHistoNDFunctor_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatHistoNDFunctor_classname)
	else:
	classname = _npstat.FloatHistoNDFunctor_classname
	if _newclass:
	version = staticmethod(_npstat.FloatHistoNDFunctor_version)
	else:
	version = _npstat.FloatHistoNDFunctor_version
	if _newclass:
	read = staticmethod(_npstat.FloatHistoNDFunctor_read)
	else:
	read = _npstat.FloatHistoNDFunctor_read
	FloatHistoNDFunctor_swigregister = _npstat.FloatHistoNDFunctor_swigregister
	FloatHistoNDFunctor_swigregister(FloatHistoNDFunctor)

	def FloatHistoNDFunctor_classname() -> "char const *":
	return _npstat.FloatHistoNDFunctor_classname()
	FloatHistoNDFunctor_classname = _npstat.FloatHistoNDFunctor_classname

	def FloatHistoNDFunctor_version() -> "unsigned int":
	return _npstat.FloatHistoNDFunctor_version()
	FloatHistoNDFunctor_version = _npstat.FloatHistoNDFunctor_version

	def FloatHistoNDFunctor_read(id: 'ClassId', arg3: 'istream') -> "npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > *":
	return _npstat.FloatHistoNDFunctor_read(id, arg3)
	FloatHistoNDFunctor_read = _npstat.FloatHistoNDFunctor_read

	class FloatUAHistoNDFunctor(StorableMultivariateFunctor):
	__swig_setmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatUAHistoNDFunctor, name, value)
	__swig_getmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatUAHistoNDFunctor, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatUAHistoNDFunctor
	__del__ = lambda self: None

	def minDim(self) -> "unsigned int":
	return _npstat.FloatUAHistoNDFunctor_minDim(self)

	def __call__(self, point: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.FloatUAHistoNDFunctor___call__(self, point, dim)

	def interpolationDegree(self) -> "unsigned int":
	return _npstat.FloatUAHistoNDFunctor_interpolationDegree(self)

	def setInterpolationDegree(self, deg: 'unsigned int const') -> "void":
	return _npstat.FloatUAHistoNDFunctor_setInterpolationDegree(self, deg)

	def interpolator(self, *args) -> "npstat::StorableHistoNDFunctor< float,npstat::HistoAxis >::Table const &":
	return _npstat.FloatUAHistoNDFunctor_interpolator(self, *args)

	def table(self, *args) -> "npstat::ArrayND< float > const &":
	return _npstat.FloatUAHistoNDFunctor_table(self, *args)

	def setConverter(self, conv: 'FloatSame') -> "void":
	return _npstat.FloatUAHistoNDFunctor_setConverter(self, conv)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatUAHistoNDFunctor_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatUAHistoNDFunctor_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatUAHistoNDFunctor_classname)
	else:
	classname = _npstat.FloatUAHistoNDFunctor_classname
	if _newclass:
	version = staticmethod(_npstat.FloatUAHistoNDFunctor_version)
	else:
	version = _npstat.FloatUAHistoNDFunctor_version
	if _newclass:
	read = staticmethod(_npstat.FloatUAHistoNDFunctor_read)
	else:
	read = _npstat.FloatUAHistoNDFunctor_read
	FloatUAHistoNDFunctor_swigregister = _npstat.FloatUAHistoNDFunctor_swigregister
	FloatUAHistoNDFunctor_swigregister(FloatUAHistoNDFunctor)

	def FloatUAHistoNDFunctor_classname() -> "char const *":
	return _npstat.FloatUAHistoNDFunctor_classname()
	FloatUAHistoNDFunctor_classname = _npstat.FloatUAHistoNDFunctor_classname

	def FloatUAHistoNDFunctor_version() -> "unsigned int":
	return _npstat.FloatUAHistoNDFunctor_version()
	FloatUAHistoNDFunctor_version = _npstat.FloatUAHistoNDFunctor_version

	def FloatUAHistoNDFunctor_read(id: 'ClassId', arg3: 'istream') -> "npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > *":
	return _npstat.FloatUAHistoNDFunctor_read(id, arg3)
	FloatUAHistoNDFunctor_read = _npstat.FloatUAHistoNDFunctor_read

	class FloatNUHistoNDFunctor(StorableMultivariateFunctor):
	__swig_setmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatNUHistoNDFunctor, name, value)
	__swig_getmethods__ = {}
	for _s in [StorableMultivariateFunctor]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, FloatNUHistoNDFunctor, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatNUHistoNDFunctor
	__del__ = lambda self: None

	def minDim(self) -> "unsigned int":
	return _npstat.FloatNUHistoNDFunctor_minDim(self)

	def __call__(self, point: 'double const *', dim: 'unsigned int') -> "double":
	return _npstat.FloatNUHistoNDFunctor___call__(self, point, dim)

	def interpolationDegree(self) -> "unsigned int":
	return _npstat.FloatNUHistoNDFunctor_interpolationDegree(self)

	def setInterpolationDegree(self, deg: 'unsigned int const') -> "void":
	return _npstat.FloatNUHistoNDFunctor_setInterpolationDegree(self, deg)

	def interpolator(self, *args) -> "npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis >::Table const &":
	return _npstat.FloatNUHistoNDFunctor_interpolator(self, *args)

	def table(self, *args) -> "npstat::ArrayND< float > const &":
	return _npstat.FloatNUHistoNDFunctor_table(self, *args)

	def setConverter(self, conv: 'FloatSame') -> "void":
	return _npstat.FloatNUHistoNDFunctor_setConverter(self, conv)

	def classId(self) -> "gs::ClassId":
	return _npstat.FloatNUHistoNDFunctor_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.FloatNUHistoNDFunctor_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.FloatNUHistoNDFunctor_classname)
	else:
	classname = _npstat.FloatNUHistoNDFunctor_classname
	if _newclass:
	version = staticmethod(_npstat.FloatNUHistoNDFunctor_version)
	else:
	version = _npstat.FloatNUHistoNDFunctor_version
	if _newclass:
	read = staticmethod(_npstat.FloatNUHistoNDFunctor_read)
	else:
	read = _npstat.FloatNUHistoNDFunctor_read
	FloatNUHistoNDFunctor_swigregister = _npstat.FloatNUHistoNDFunctor_swigregister
	FloatNUHistoNDFunctor_swigregister(FloatNUHistoNDFunctor)

	def FloatNUHistoNDFunctor_classname() -> "char const *":
	return _npstat.FloatNUHistoNDFunctor_classname()
	FloatNUHistoNDFunctor_classname = _npstat.FloatNUHistoNDFunctor_classname

	def FloatNUHistoNDFunctor_version() -> "unsigned int":
	return _npstat.FloatNUHistoNDFunctor_version()
	FloatNUHistoNDFunctor_version = _npstat.FloatNUHistoNDFunctor_version

	def FloatNUHistoNDFunctor_read(id: 'ClassId', arg3: 'istream') -> "npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > *":
	return _npstat.FloatNUHistoNDFunctor_read(id, arg3)
	FloatNUHistoNDFunctor_read = _npstat.FloatNUHistoNDFunctor_read

	class StatAccumulatorArr(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, StatAccumulatorArr, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, StatAccumulatorArr, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_StatAccumulatorArr(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned long":
	return _npstat.StatAccumulatorArr_dim(self)

	def count(self) -> "unsigned long":
	return _npstat.StatAccumulatorArr_count(self)

	def min(self, i: 'unsigned long') -> "double":
	return _npstat.StatAccumulatorArr_min(self, i)

	def max(self, i: 'unsigned long') -> "double":
	return _npstat.StatAccumulatorArr_max(self, i)

	def mean(self, i: 'unsigned long') -> "double":
	return _npstat.StatAccumulatorArr_mean(self, i)

	def stdev(self, i: 'unsigned long') -> "double":
	return _npstat.StatAccumulatorArr_stdev(self, i)

	def meanUncertainty(self, i: 'unsigned long') -> "double":
	return _npstat.StatAccumulatorArr_meanUncertainty(self, i)

	def accumulate(self, acc: 'StatAccumulatorArr') -> "void":
	return _npstat.StatAccumulatorArr_accumulate(self, acc)

	def reset(self) -> "void":
	return _npstat.StatAccumulatorArr_reset(self)

	def __add__(self, r: 'StatAccumulatorArr') -> "npstat::StatAccumulatorArr":
	return _npstat.StatAccumulatorArr___add__(self, r)

	def __eq__(self, r: 'StatAccumulatorArr') -> "bool":
	return _npstat.StatAccumulatorArr___eq__(self, r)

	def __ne__(self, r: 'StatAccumulatorArr') -> "bool":
	return _npstat.StatAccumulatorArr___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.StatAccumulatorArr_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.StatAccumulatorArr_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.StatAccumulatorArr_classname)
	else:
	classname = _npstat.StatAccumulatorArr_classname
	if _newclass:
	version = staticmethod(_npstat.StatAccumulatorArr_version)
	else:
	version = _npstat.StatAccumulatorArr_version
	if _newclass:
	restore = staticmethod(_npstat.StatAccumulatorArr_restore)
	else:
	restore = _npstat.StatAccumulatorArr_restore

	def __mul__(self, r: 'double const') -> "npstat::StatAccumulatorArr":
	return _npstat.StatAccumulatorArr___mul__(self, r)

	def __div__(self, r: 'double const') -> "npstat::StatAccumulatorArr":
	return _npstat.StatAccumulatorArr___div__(self, r)

	def __imul__(self, r: 'double const') -> "npstat::StatAccumulatorArr &":
	return _npstat.StatAccumulatorArr___imul__(self, r)

	def __idiv__(self, r: 'double const') -> "npstat::StatAccumulatorArr &":
	return _npstat.StatAccumulatorArr___idiv__(self, r)

	def minArray(self, arr: 'double *', len: 'unsigned long const') -> "void":
	return _npstat.StatAccumulatorArr_minArray(self, arr, len)

	def maxArray(self, arr: 'double *', len: 'unsigned long const') -> "void":
	return _npstat.StatAccumulatorArr_maxArray(self, arr, len)

	def meanArray(self, arr: 'double *', len: 'unsigned long const') -> "void":
	return _npstat.StatAccumulatorArr_meanArray(self, arr, len)

	def stdevArray(self, arr: 'double *', len: 'unsigned long const') -> "void":
	return _npstat.StatAccumulatorArr_stdevArray(self, arr, len)

	def meanUncertaintyArray(self, arr: 'double *', len: 'unsigned long const') -> "void":
	return _npstat.StatAccumulatorArr_meanUncertaintyArray(self, arr, len)

	def __iadd__(self, *args) -> "npstat::StatAccumulatorArr &":
	return _npstat.StatAccumulatorArr___iadd__(self, *args)
	__swig_destroy__ = _npstat.delete_StatAccumulatorArr
	__del__ = lambda self: None
	StatAccumulatorArr_swigregister = _npstat.StatAccumulatorArr_swigregister
	StatAccumulatorArr_swigregister(StatAccumulatorArr)

	def StatAccumulatorArr_classname() -> "char const *":
	return _npstat.StatAccumulatorArr_classname()
	StatAccumulatorArr_classname = _npstat.StatAccumulatorArr_classname

	def StatAccumulatorArr_version() -> "unsigned int":
	return _npstat.StatAccumulatorArr_version()
	StatAccumulatorArr_version = _npstat.StatAccumulatorArr_version

	def StatAccumulatorArr_restore(id: 'ClassId', arg3: 'istream', acc: 'StatAccumulatorArr') -> "void":
	return _npstat.StatAccumulatorArr_restore(id, arg3, acc)
	StatAccumulatorArr_restore = _npstat.StatAccumulatorArr_restore


	def convertToHistoAxis(*args) -> "npstat::NUHistoAxis":
	return _npstat.convertToHistoAxis(*args)
	convertToHistoAxis = _npstat.convertToHistoAxis

	def convertToGridAxis(*args) -> "npstat::DualAxis":
	return _npstat.convertToGridAxis(*args)
	convertToGridAxis = _npstat.convertToGridAxis
	class InterpolatedDistribution1D(AbsInterpolatedDistribution1D):
	__swig_setmethods__ = {}
	for _s in [AbsInterpolatedDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, InterpolatedDistribution1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsInterpolatedDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, InterpolatedDistribution1D, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_InterpolatedDistribution1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_InterpolatedDistribution1D
	__del__ = lambda self: None

	def clone(self) -> "npstat::InterpolatedDistribution1D *":
	return _npstat.InterpolatedDistribution1D_clone(self)

	def add(self, d: 'AbsDistribution1D', weight: 'double') -> "void":
	return _npstat.InterpolatedDistribution1D_add(self, d, weight)

	def replace(self, i: 'unsigned int', d: 'AbsDistribution1D', weight: 'double') -> "void":
	return _npstat.InterpolatedDistribution1D_replace(self, i, d, weight)

	def setWeight(self, i: 'unsigned int', weight: 'double') -> "void":
	return _npstat.InterpolatedDistribution1D_setWeight(self, i, weight)

	def clear(self) -> "void":
	return _npstat.InterpolatedDistribution1D_clear(self)

	def normalizeAutomatically(self, allow: 'bool') -> "void":
	return _npstat.InterpolatedDistribution1D_normalizeAutomatically(self, allow)

	def size(self) -> "unsigned int":
	return _npstat.InterpolatedDistribution1D_size(self)

	def expectedSize(self) -> "unsigned int":
	return _npstat.InterpolatedDistribution1D_expectedSize(self)

	def density(self, x: 'double') -> "double":
	return _npstat.InterpolatedDistribution1D_density(self, x)

	def cdf(self, x: 'double') -> "double":
	return _npstat.InterpolatedDistribution1D_cdf(self, x)

	def exceedance(self, x: 'double') -> "double":
	return _npstat.InterpolatedDistribution1D_exceedance(self, x)

	def quantile(self, x: 'double') -> "double":
	return _npstat.InterpolatedDistribution1D_quantile(self, x)

	def densityAndCdf(self, x: 'double', pdensity: 'double ', pcdf: 'double ') -> "void":
	return _npstat.InterpolatedDistribution1D_densityAndCdf(self, x, pdensity, pcdf)

	def classId(self) -> "gs::ClassId":
	return _npstat.InterpolatedDistribution1D_classId(self)
	if _newclass:
	classname = staticmethod(_npstat.InterpolatedDistribution1D_classname)
	else:
	classname = _npstat.InterpolatedDistribution1D_classname
	if _newclass:
	version = staticmethod(_npstat.InterpolatedDistribution1D_version)
	else:
	version = _npstat.InterpolatedDistribution1D_version
	InterpolatedDistribution1D_swigregister = _npstat.InterpolatedDistribution1D_swigregister
	InterpolatedDistribution1D_swigregister(InterpolatedDistribution1D)

	def InterpolatedDistribution1D_classname() -> "char const *":
	return _npstat.InterpolatedDistribution1D_classname()
	InterpolatedDistribution1D_classname = _npstat.InterpolatedDistribution1D_classname

	def InterpolatedDistribution1D_version() -> "unsigned int":
	return _npstat.InterpolatedDistribution1D_version()
	InterpolatedDistribution1D_version = _npstat.InterpolatedDistribution1D_version

	class Ref_IntArchivedNtuple(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_IntArchivedNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_IntArchivedNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_IntArchivedNtuple(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_Ref_IntArchivedNtuple
	__del__ = lambda self: None

	def retrieve(self, index: 'unsigned long') -> "npstat::ArchivedNtuple< int > *":
	return _npstat.Ref_IntArchivedNtuple_retrieve(self, index)
	Ref_IntArchivedNtuple_swigregister = _npstat.Ref_IntArchivedNtuple_swigregister
	Ref_IntArchivedNtuple_swigregister(Ref_IntArchivedNtuple)

	class Ref_LLongArchivedNtuple(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_LLongArchivedNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_LLongArchivedNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_LLongArchivedNtuple(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_Ref_LLongArchivedNtuple
	__del__ = lambda self: None

	def retrieve(self, index: 'unsigned long') -> "npstat::ArchivedNtuple< long long > *":
	return _npstat.Ref_LLongArchivedNtuple_retrieve(self, index)
	Ref_LLongArchivedNtuple_swigregister = _npstat.Ref_LLongArchivedNtuple_swigregister
	Ref_LLongArchivedNtuple_swigregister(Ref_LLongArchivedNtuple)

	class Ref_UCharArchivedNtuple(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_UCharArchivedNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_UCharArchivedNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_UCharArchivedNtuple(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_Ref_UCharArchivedNtuple
	__del__ = lambda self: None

	def retrieve(self, index: 'unsigned long') -> "npstat::ArchivedNtuple< unsigned char > *":
	return _npstat.Ref_UCharArchivedNtuple_retrieve(self, index)
	Ref_UCharArchivedNtuple_swigregister = _npstat.Ref_UCharArchivedNtuple_swigregister
	Ref_UCharArchivedNtuple_swigregister(Ref_UCharArchivedNtuple)

	class Ref_FloatArchivedNtuple(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_FloatArchivedNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_FloatArchivedNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_FloatArchivedNtuple(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_Ref_FloatArchivedNtuple
	__del__ = lambda self: None

	def retrieve(self, index: 'unsigned long') -> "npstat::ArchivedNtuple< float > *":
	return _npstat.Ref_FloatArchivedNtuple_retrieve(self, index)
	Ref_FloatArchivedNtuple_swigregister = _npstat.Ref_FloatArchivedNtuple_swigregister
	Ref_FloatArchivedNtuple_swigregister(Ref_FloatArchivedNtuple)

	class Ref_DoubleArchivedNtuple(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DoubleArchivedNtuple, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DoubleArchivedNtuple, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DoubleArchivedNtuple(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_Ref_DoubleArchivedNtuple
	__del__ = lambda self: None

	def retrieve(self, index: 'unsigned long') -> "npstat::ArchivedNtuple< double > *":
	return _npstat.Ref_DoubleArchivedNtuple_retrieve(self, index)
	Ref_DoubleArchivedNtuple_swigregister = _npstat.Ref_DoubleArchivedNtuple_swigregister
	Ref_DoubleArchivedNtuple_swigregister(Ref_DoubleArchivedNtuple)

	class CompositeGauss1D(CompositeDistribution1D):
	__swig_setmethods__ = {}
	for _s in [CompositeDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, CompositeGauss1D, name, value)
	__swig_getmethods__ = {}
	for _s in [CompositeDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, CompositeGauss1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_CompositeGauss1D
	__del__ = lambda self: None

	def clone(self) -> "npstat::CompositeGauss1D *":
	return _npstat.CompositeGauss1D_clone(self)
	CompositeGauss1D_swigregister = _npstat.CompositeGauss1D_swigregister
	CompositeGauss1D_swigregister(CompositeGauss1D)

	class BetaGauss1D(CompositeDistribution1D):
	__swig_setmethods__ = {}
	for _s in [CompositeDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, BetaGauss1D, name, value)
	__swig_getmethods__ = {}
	for _s in [CompositeDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, BetaGauss1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_BetaGauss1D
	__del__ = lambda self: None

	def clone(self) -> "npstat::BetaGauss1D *":
	return _npstat.BetaGauss1D_clone(self)
	BetaGauss1D_swigregister = _npstat.BetaGauss1D_swigregister
	BetaGauss1D_swigregister(BetaGauss1D)

	class LogQuadraticLadder(CompositeDistribution1D):
	__swig_setmethods__ = {}
	for _s in [CompositeDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LogQuadraticLadder, name, value)
	__swig_getmethods__ = {}
	for _s in [CompositeDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LogQuadraticLadder, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LogQuadraticLadder
	__del__ = lambda self: None

	def clone(self) -> "npstat::LogQuadraticLadder *":
	return _npstat.LogQuadraticLadder_clone(self)
	LogQuadraticLadder_swigregister = _npstat.LogQuadraticLadder_swigregister
	LogQuadraticLadder_swigregister(LogQuadraticLadder)

	class BinnedCompositeJohnson(CompositeDistribution1D):
	__swig_setmethods__ = {}
	for _s in [CompositeDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, BinnedCompositeJohnson, name, value)
	__swig_getmethods__ = {}
	for _s in [CompositeDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, BinnedCompositeJohnson, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_BinnedCompositeJohnson
	__del__ = lambda self: None

	def clone(self) -> "npstat::BinnedCompositeJohnson *":
	return _npstat.BinnedCompositeJohnson_clone(self)
	BinnedCompositeJohnson_swigregister = _npstat.BinnedCompositeJohnson_swigregister
	BinnedCompositeJohnson_swigregister(BinnedCompositeJohnson)

	class JohnsonLadder(CompositeDistribution1D):
	__swig_setmethods__ = {}
	for _s in [CompositeDistribution1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, JohnsonLadder, name, value)
	__swig_getmethods__ = {}
	for _s in [CompositeDistribution1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, JohnsonLadder, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_JohnsonLadder
	__del__ = lambda self: None

	def clone(self) -> "npstat::JohnsonLadder *":
	return _npstat.JohnsonLadder_clone(self)
	JohnsonLadder_swigregister = _npstat.JohnsonLadder_swigregister
	JohnsonLadder_swigregister(JohnsonLadder)

	class PolyFilter1D(LDoubleVector):
	__swig_setmethods__ = {}
	for _s in [LDoubleVector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, PolyFilter1D, name, value)
	__swig_getmethods__ = {}
	for _s in [LDoubleVector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, PolyFilter1D, name)
	__repr__ = _swig_repr

	def __init__(self, peak: 'unsigned int const'):
	this = _npstat.new_PolyFilter1D(peak)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def peakPosition(self) -> "unsigned int":
	return _npstat.PolyFilter1D_peakPosition(self)

	def __eq__(self, r: 'PolyFilter1D') -> "bool":
	return _npstat.PolyFilter1D___eq__(self, r)

	def __ne__(self, r: 'PolyFilter1D') -> "bool":
	return _npstat.PolyFilter1D___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.PolyFilter1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.PolyFilter1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.PolyFilter1D_classname)
	else:
	classname = _npstat.PolyFilter1D_classname
	if _newclass:
	version = staticmethod(_npstat.PolyFilter1D_version)
	else:
	version = _npstat.PolyFilter1D_version
	if _newclass:
	read = staticmethod(_npstat.PolyFilter1D_read)
	else:
	read = _npstat.PolyFilter1D_read
	__swig_destroy__ = _npstat.delete_PolyFilter1D
	__del__ = lambda self: None
	PolyFilter1D_swigregister = _npstat.PolyFilter1D_swigregister
	PolyFilter1D_swigregister(PolyFilter1D)

	def PolyFilter1D_classname() -> "char const *":
	return _npstat.PolyFilter1D_classname()
	PolyFilter1D_classname = _npstat.PolyFilter1D_classname

	def PolyFilter1D_version() -> "unsigned int":
	return _npstat.PolyFilter1D_version()
	PolyFilter1D_version = _npstat.PolyFilter1D_version

	def PolyFilter1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::PolyFilter1D *":
	return _npstat.PolyFilter1D_read(id, arg3)
	PolyFilter1D_read = _npstat.PolyFilter1D_read

	class AbsFilter1DBuilder(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsFilter1DBuilder, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, AbsFilter1DBuilder, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsFilter1DBuilder
	__del__ = lambda self: None

	def centralWeightLength(self) -> "unsigned int":
	return _npstat.AbsFilter1DBuilder_centralWeightLength(self)

	def keepAllFilters(self) -> "bool":
	return _npstat.AbsFilter1DBuilder_keepAllFilters(self)

	def makeFilter(self, taper: 'double const ', maxDegree: 'unsigned int', binnum: 'unsigned int', datalen: 'unsigned int') -> "npstat::PolyFilter1D ":
	return _npstat.AbsFilter1DBuilder_makeFilter(self, taper, maxDegree, binnum, datalen)

	def lastBandwidthFactor(self) -> "double":
	return _npstat.AbsFilter1DBuilder_lastBandwidthFactor(self)
	AbsFilter1DBuilder_swigregister = _npstat.AbsFilter1DBuilder_swigregister
	AbsFilter1DBuilder_swigregister(AbsFilter1DBuilder)

	class OrthoPolyFilter1DBuilder(AbsFilter1DBuilder):
	__swig_setmethods__ = {}
	for _s in [AbsFilter1DBuilder]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, OrthoPolyFilter1DBuilder, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsFilter1DBuilder]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, OrthoPolyFilter1DBuilder, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_OrthoPolyFilter1DBuilder
	__del__ = lambda self: None

	def makeFilter(self, taper: 'double const ', maxDegree: 'unsigned int', binnum: 'unsigned int', datalen: 'unsigned int') -> "npstat::PolyFilter1D ":
	return _npstat.OrthoPolyFilter1DBuilder_makeFilter(self, taper, maxDegree, binnum, datalen)

	def makeOrthoPoly(self, maxDegree: 'unsigned int', binnum: 'unsigned int', datalen: 'unsigned int', filterCenter: 'unsigned int ') -> "npstat::OrthoPoly1D ":
	return _npstat.OrthoPolyFilter1DBuilder_makeOrthoPoly(self, maxDegree, binnum, datalen, filterCenter)
	OrthoPolyFilter1DBuilder_swigregister = _npstat.OrthoPolyFilter1DBuilder_swigregister
	OrthoPolyFilter1DBuilder_swigregister(OrthoPolyFilter1DBuilder)

	class AbsBoundaryFilter1DBuilder(OrthoPolyFilter1DBuilder):
	__swig_setmethods__ = {}
	for _s in [OrthoPolyFilter1DBuilder]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsBoundaryFilter1DBuilder, name, value)
	__swig_getmethods__ = {}
	for _s in [OrthoPolyFilter1DBuilder]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, AbsBoundaryFilter1DBuilder, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsBoundaryFilter1DBuilder
	__del__ = lambda self: None

	def centralWeightLength(self) -> "unsigned int":
	return _npstat.AbsBoundaryFilter1DBuilder_centralWeightLength(self)

	def keepAllFilters(self) -> "bool":
	return _npstat.AbsBoundaryFilter1DBuilder_keepAllFilters(self)

	def makeOrthoPoly(self, maxDegree: 'unsigned int', binnum: 'unsigned int', datalen: 'unsigned int', filterCenter: 'unsigned int ') -> "npstat::OrthoPoly1D ":
	return _npstat.AbsBoundaryFilter1DBuilder_makeOrthoPoly(self, maxDegree, binnum, datalen, filterCenter)

	def isFolding(self) -> "bool":
	return _npstat.AbsBoundaryFilter1DBuilder_isFolding(self)

	def lastBandwidthFactor(self) -> "double":
	return _npstat.AbsBoundaryFilter1DBuilder_lastBandwidthFactor(self)
	AbsBoundaryFilter1DBuilder_swigregister = _npstat.AbsBoundaryFilter1DBuilder_swigregister
	AbsBoundaryFilter1DBuilder_swigregister(AbsBoundaryFilter1DBuilder)


	def getBoundaryFilter1DBuilder(boundaryMethod: 'BoundaryHandling', distro: 'AbsDistribution1D', stepSize: 'double', exclusionMask: 'IntVector'=None, excludeCentralPoint: 'bool'=False) -> "npstat::AbsBoundaryFilter1DBuilder *":
	return _npstat.getBoundaryFilter1DBuilder(boundaryMethod, distro, stepSize, exclusionMask, excludeCentralPoint)
	getBoundaryFilter1DBuilder = _npstat.getBoundaryFilter1DBuilder
	class LocalPolyFilter1D(AbsPolyFilter1D):
	__swig_setmethods__ = {}
	for _s in [AbsPolyFilter1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LocalPolyFilter1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsPolyFilter1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LocalPolyFilter1D, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_LocalPolyFilter1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_LocalPolyFilter1D
	__del__ = lambda self: None

	def __eq__(self, r: 'LocalPolyFilter1D') -> "bool":
	return _npstat.LocalPolyFilter1D___eq__(self, r)

	def __ne__(self, r: 'LocalPolyFilter1D') -> "bool":
	return _npstat.LocalPolyFilter1D___ne__(self, r)

	def taper(self, degree: 'unsigned int') -> "double":
	return _npstat.LocalPolyFilter1D_taper(self, degree)

	def maxDegree(self) -> "unsigned int":
	return _npstat.LocalPolyFilter1D_maxDegree(self)

	def dataLen(self) -> "unsigned int":
	return _npstat.LocalPolyFilter1D_dataLen(self)

	def getBandwidthFactors(self) -> "std::vector< double,std::allocator< double > > const &":
	return _npstat.LocalPolyFilter1D_getBandwidthFactors(self)

	def selfContribution(self, binNumber: 'unsigned int') -> "double":
	return _npstat.LocalPolyFilter1D_selfContribution(self, binNumber)

	def getFilter(self, binNumber: 'unsigned int') -> "npstat::PolyFilter1D const &":
	return _npstat.LocalPolyFilter1D_getFilter(self, binNumber)

	def getFilterMatrix(self) -> "npstat::Matrix< double >":
	return _npstat.LocalPolyFilter1D_getFilterMatrix(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.LocalPolyFilter1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.LocalPolyFilter1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.LocalPolyFilter1D_classname)
	else:
	classname = _npstat.LocalPolyFilter1D_classname
	if _newclass:
	version = staticmethod(_npstat.LocalPolyFilter1D_version)
	else:
	version = _npstat.LocalPolyFilter1D_version
	if _newclass:
	read = staticmethod(_npstat.LocalPolyFilter1D_read)
	else:
	read = _npstat.LocalPolyFilter1D_read

	def doublyStochasticFilter(self, tolerance: 'double', maxIterations: 'unsigned int') -> "npstat::LocalPolyFilter1D *":
	return _npstat.LocalPolyFilter1D_doublyStochasticFilter(self, tolerance, maxIterations)

	def eigenGroomedFilter(self) -> "npstat::LocalPolyFilter1D *":
	return _npstat.LocalPolyFilter1D_eigenGroomedFilter(self)

	def filter(self, arg2: 'double const ', out: 'double ') -> "void":
	return _npstat.LocalPolyFilter1D_filter(self, arg2, out)

	def convolve(self, arg2: 'double const ', out: 'double ') -> "void":
	return _npstat.LocalPolyFilter1D_convolve(self, arg2, out)
	LocalPolyFilter1D_swigregister = _npstat.LocalPolyFilter1D_swigregister
	LocalPolyFilter1D_swigregister(LocalPolyFilter1D)

	def LocalPolyFilter1D_classname() -> "char const *":
	return _npstat.LocalPolyFilter1D_classname()
	LocalPolyFilter1D_classname = _npstat.LocalPolyFilter1D_classname

	def LocalPolyFilter1D_version() -> "unsigned int":
	return _npstat.LocalPolyFilter1D_version()
	LocalPolyFilter1D_version = _npstat.LocalPolyFilter1D_version

	def LocalPolyFilter1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::LocalPolyFilter1D *":
	return _npstat.LocalPolyFilter1D_read(id, arg3)
	LocalPolyFilter1D_read = _npstat.LocalPolyFilter1D_read

	class DummyLocalPolyFilter1D(LocalPolyFilter1D):
	__swig_setmethods__ = {}
	for _s in [LocalPolyFilter1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, DummyLocalPolyFilter1D, name, value)
	__swig_getmethods__ = {}
	for _s in [LocalPolyFilter1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, DummyLocalPolyFilter1D, name)
	__repr__ = _swig_repr

	def __init__(self, dataLen: 'unsigned int'):
	this = _npstat.new_DummyLocalPolyFilter1D(dataLen)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_DummyLocalPolyFilter1D
	__del__ = lambda self: None

	def classId(self) -> "gs::ClassId":
	return _npstat.DummyLocalPolyFilter1D_classId(self)

	def write(self, os: 'ostream') -> "bool":
	return _npstat.DummyLocalPolyFilter1D_write(self, os)
	if _newclass:
	classname = staticmethod(_npstat.DummyLocalPolyFilter1D_classname)
	else:
	classname = _npstat.DummyLocalPolyFilter1D_classname
	if _newclass:
	version = staticmethod(_npstat.DummyLocalPolyFilter1D_version)
	else:
	version = _npstat.DummyLocalPolyFilter1D_version
	if _newclass:
	read = staticmethod(_npstat.DummyLocalPolyFilter1D_read)
	else:
	read = _npstat.DummyLocalPolyFilter1D_read
	DummyLocalPolyFilter1D_swigregister = _npstat.DummyLocalPolyFilter1D_swigregister
	DummyLocalPolyFilter1D_swigregister(DummyLocalPolyFilter1D)

	def DummyLocalPolyFilter1D_classname() -> "char const *":
	return _npstat.DummyLocalPolyFilter1D_classname()
	DummyLocalPolyFilter1D_classname = _npstat.DummyLocalPolyFilter1D_classname

	def DummyLocalPolyFilter1D_version() -> "unsigned int":
	return _npstat.DummyLocalPolyFilter1D_version()
	DummyLocalPolyFilter1D_version = _npstat.DummyLocalPolyFilter1D_version

	def DummyLocalPolyFilter1D_read(id: 'ClassId', arg3: 'istream') -> "npstat::DummyLocalPolyFilter1D *":
	return _npstat.DummyLocalPolyFilter1D_read(id, arg3)
	DummyLocalPolyFilter1D_read = _npstat.DummyLocalPolyFilter1D_read


	def symbetaWeightAt0(m: 'int', bandwidth: 'double') -> "double":
	return _npstat.symbetaWeightAt0(m, bandwidth)
	symbetaWeightAt0 = _npstat.symbetaWeightAt0

	def symbetaLOrPEFilter1D(m: 'int', bandwidth: 'double', maxDegree: 'double', numberOfGridPoints: 'unsigned int', xmin: 'double', xmax: 'double', boundaryMethod: 'BoundaryHandling', exclusionMask: 'IntVector'=None, excludeCentralPoint: 'bool'=False) -> "npstat::LocalPolyFilter1D *":
	return _npstat.symbetaLOrPEFilter1D(m, bandwidth, maxDegree, numberOfGridPoints, xmin, xmax, boundaryMethod, exclusionMask, excludeCentralPoint)
	symbetaLOrPEFilter1D = _npstat.symbetaLOrPEFilter1D
	class ScalableGaussND(AbsScalableDistributionND):
	__swig_setmethods__ = {}
	for _s in [AbsScalableDistributionND]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ScalableGaussND, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsScalableDistributionND]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ScalableGaussND, name)
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_ScalableGaussND
	__del__ = lambda self: None

	def clone(self) -> "npstat::ScalableGaussND *":
	return _npstat.ScalableGaussND_clone(self)

	def mappedByQuantiles(self) -> "bool":
	return _npstat.ScalableGaussND_mappedByQuantiles(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.ScalableGaussND_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.ScalableGaussND_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.ScalableGaussND_classname)
	else:
	classname = _npstat.ScalableGaussND_classname
	if _newclass:
	version = staticmethod(_npstat.ScalableGaussND_version)
	else:
	version = _npstat.ScalableGaussND_version
	if _newclass:
	read = staticmethod(_npstat.ScalableGaussND_read)
	else:
	read = _npstat.ScalableGaussND_read

	def __init__(self, *args):
	this = _npstat.new_ScalableGaussND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	ScalableGaussND_swigregister = _npstat.ScalableGaussND_swigregister
	ScalableGaussND_swigregister(ScalableGaussND)

	def ScalableGaussND_classname() -> "char const *":
	return _npstat.ScalableGaussND_classname()
	ScalableGaussND_classname = _npstat.ScalableGaussND_classname

	def ScalableGaussND_version() -> "unsigned int":
	return _npstat.ScalableGaussND_version()
	ScalableGaussND_version = _npstat.ScalableGaussND_version

	def ScalableGaussND_read(id: 'ClassId', arg3: 'istream') -> "npstat::ScalableGaussND *":
	return _npstat.ScalableGaussND_read(id, arg3)
	ScalableGaussND_read = _npstat.ScalableGaussND_read


	def inverseGaussCdf(cdf: 'double') -> "double":
	return _npstat.inverseGaussCdf(cdf)
	inverseGaussCdf = _npstat.inverseGaussCdf

	def incompleteBeta(a: 'double', b: 'double', x: 'double') -> "double":
	return _npstat.incompleteBeta(a, b, x)
	incompleteBeta = _npstat.incompleteBeta

	def inverseIncompleteBeta(a: 'double', b: 'double', x: 'double') -> "double":
	return _npstat.inverseIncompleteBeta(a, b, x)
	inverseIncompleteBeta = _npstat.inverseIncompleteBeta

	def Gamma(x: 'double') -> "double":
	return _npstat.Gamma(x)
	Gamma = _npstat.Gamma

	def incompleteGamma(a: 'double', x: 'double') -> "double":
	return _npstat.incompleteGamma(a, x)
	incompleteGamma = _npstat.incompleteGamma

	def incompleteGammaC(a: 'double', x: 'double') -> "double":
	return _npstat.incompleteGammaC(a, x)
	incompleteGammaC = _npstat.incompleteGammaC

	def inverseIncompleteGamma(a: 'double', x: 'double') -> "double":
	return _npstat.inverseIncompleteGamma(a, x)
	inverseIncompleteGamma = _npstat.inverseIncompleteGamma

	def inverseIncompleteGammaC(a: 'double', x: 'double') -> "double":
	return _npstat.inverseIncompleteGammaC(a, x)
	inverseIncompleteGammaC = _npstat.inverseIncompleteGammaC

	def dawsonIntegral(x: 'long double') -> "long double":
	return _npstat.dawsonIntegral(x)
	dawsonIntegral = _npstat.dawsonIntegral

	def inverseExpsqIntegral(x: 'long double') -> "long double":
	return _npstat.inverseExpsqIntegral(x)
	inverseExpsqIntegral = _npstat.inverseExpsqIntegral

	def normalDensityDerivative(n: 'unsigned int', x: 'long double') -> "long double":
	return _npstat.normalDensityDerivative(n, x)
	normalDensityDerivative = _npstat.normalDensityDerivative

	def bivariateNormalIntegral(rho: 'double', x: 'double', y: 'double') -> "double":
	return _npstat.bivariateNormalIntegral(rho, x, y)
	bivariateNormalIntegral = _npstat.bivariateNormalIntegral
	class Peak2D(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, Peak2D, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, Peak2D, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_Peak2D()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def rescaleCoords(self, centerCellCoordinateInX: 'double', gridCellWidthInX: 'double', centerCellCoordinateInY: 'double', gridCellWidthInY: 'double') -> "void":
	return _npstat.Peak2D_rescaleCoords(self, centerCellCoordinateInX, gridCellWidthInX, centerCellCoordinateInY, gridCellWidthInY)
	__swig_setmethods__["x"] = _npstat.Peak2D_x_set
	__swig_getmethods__["x"] = _npstat.Peak2D_x_get
	if _newclass:
	x = _swig_property(_npstat.Peak2D_x_get, _npstat.Peak2D_x_set)
	__swig_setmethods__["y"] = _npstat.Peak2D_y_set
	__swig_getmethods__["y"] = _npstat.Peak2D_y_get
	if _newclass:
	y = _swig_property(_npstat.Peak2D_y_get, _npstat.Peak2D_y_set)
	__swig_setmethods__["magnitude"] = _npstat.Peak2D_magnitude_set
	__swig_getmethods__["magnitude"] = _npstat.Peak2D_magnitude_get
	if _newclass:
	magnitude = _swig_property(_npstat.Peak2D_magnitude_get, _npstat.Peak2D_magnitude_set)
	__swig_setmethods__["hessian"] = _npstat.Peak2D_hessian_set
	__swig_getmethods__["hessian"] = _npstat.Peak2D_hessian_get
	if _newclass:
	hessian = _swig_property(_npstat.Peak2D_hessian_get, _npstat.Peak2D_hessian_set)
	__swig_setmethods__["valid"] = _npstat.Peak2D_valid_set
	__swig_getmethods__["valid"] = _npstat.Peak2D_valid_get
	if _newclass:
	valid = _swig_property(_npstat.Peak2D_valid_get, _npstat.Peak2D_valid_set)
	__swig_setmethods__["inside"] = _npstat.Peak2D_inside_set
	__swig_getmethods__["inside"] = _npstat.Peak2D_inside_get
	if _newclass:
	inside = _swig_property(_npstat.Peak2D_inside_get, _npstat.Peak2D_inside_set)
	__swig_destroy__ = _npstat.delete_Peak2D
	__del__ = lambda self: None
	Peak2D_swigregister = _npstat.Peak2D_swigregister
	Peak2D_swigregister(Peak2D)


	def findPeak3by3(gridValues: 'double const [3][3]', peak: 'Peak2D') -> "bool":
	return _npstat.findPeak3by3(gridValues, peak)
	findPeak3by3 = _npstat.findPeak3by3

	def findPeak5by5(gridValues: 'double const [5][5]', peak: 'Peak2D') -> "bool":
	return _npstat.findPeak5by5(gridValues, peak)
	findPeak5by5 = _npstat.findPeak5by5

	def rectangleIntegralCenterAndSize(f: 'AbsMultivariateFunctor', rectangleCenter: 'double const ', rectangleSize: 'double const ', dim: 'unsigned int', integrationPoints: 'unsigned int') -> "double":
	return _npstat.rectangleIntegralCenterAndSize(f, rectangleCenter, rectangleSize, dim, integrationPoints)
	rectangleIntegralCenterAndSize = _npstat.rectangleIntegralCenterAndSize

	def binomialCoefficient(N: 'unsigned int', M: 'unsigned int') -> "unsigned long":
	return _npstat.binomialCoefficient(N, M)
	binomialCoefficient = _npstat.binomialCoefficient

	def ldBinomialCoefficient(N: 'unsigned int', M: 'unsigned int') -> "long double":
	return _npstat.ldBinomialCoefficient(N, M)
	ldBinomialCoefficient = _npstat.ldBinomialCoefficient

	def findRootInLogSpace(f: 'DoubleDoubleFunctor1', rhs: 'double const &', x0: 'double const &', tol: 'double', x: 'double *', logstep: 'double'=0.5) -> "bool":
	return _npstat.findRootInLogSpace(f, rhs, x0, tol, x, logstep)
	findRootInLogSpace = _npstat.findRootInLogSpace
	OPOLY_STIELTJES = _npstat.OPOLY_STIELTJES
	OPOLY_LANCZOS = _npstat.OPOLY_LANCZOS

	def parseOrthoPolyMethod(methodName: 'char const *') -> "npstat::OrthoPolyMethod":
	return _npstat.parseOrthoPolyMethod(methodName)
	parseOrthoPolyMethod = _npstat.parseOrthoPolyMethod

	def orthoPolyMethodName(m: 'npstat::OrthoPolyMethod') -> "char const *":
	return _npstat.orthoPolyMethodName(m)
	orthoPolyMethodName = _npstat.orthoPolyMethodName

	def validOrthoPolyMethodNames() -> "std::string":
	return _npstat.validOrthoPolyMethodNames()
	validOrthoPolyMethodNames = _npstat.validOrthoPolyMethodNames
	class ContOrthoPoly1D(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, ContOrthoPoly1D, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, ContOrthoPoly1D, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_ContOrthoPoly1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def maxDegree(self) -> "unsigned int":
	return _npstat.ContOrthoPoly1D_maxDegree(self)

	def measureLength(self) -> "unsigned long":
	return _npstat.ContOrthoPoly1D_measureLength(self)

	def measure(self, index: 'unsigned int const') -> "npstat::ContOrthoPoly1D::MeasurePoint":
	return _npstat.ContOrthoPoly1D_measure(self, index)

	def coordinate(self, index: 'unsigned int const') -> "double":
	return _npstat.ContOrthoPoly1D_coordinate(self, index)

	def weight(self, index: 'unsigned int const') -> "double":
	return _npstat.ContOrthoPoly1D_weight(self, index)

	def sumOfWeights(self) -> "double":
	return _npstat.ContOrthoPoly1D_sumOfWeights(self)

	def sumOfWeightSquares(self) -> "double":
	return _npstat.ContOrthoPoly1D_sumOfWeightSquares(self)

	def areAllWeightsEqual(self) -> "bool":
	return _npstat.ContOrthoPoly1D_areAllWeightsEqual(self)

	def minCoordinate(self) -> "double":
	return _npstat.ContOrthoPoly1D_minCoordinate(self)

	def maxCoordinate(self) -> "double":
	return _npstat.ContOrthoPoly1D_maxCoordinate(self)

	def meanCoordinate(self) -> "double":
	return _npstat.ContOrthoPoly1D_meanCoordinate(self)

	def effectiveSampleSize(self) -> "double":
	return _npstat.ContOrthoPoly1D_effectiveSampleSize(self)

	def poly(self, deg: 'unsigned int', x: 'double') -> "double":
	return _npstat.ContOrthoPoly1D_poly(self, deg, x)

	def polyPair(self, deg1: 'unsigned int', deg2: 'unsigned int', x: 'double') -> "std::pair< double,double >":
	return _npstat.ContOrthoPoly1D_polyPair(self, deg1, deg2, x)

	def allPolys(self, *args) -> "void":
	return _npstat.ContOrthoPoly1D_allPolys(self, *args)

	def series(self, coeffs: 'double const *', maxdeg: 'unsigned int', x: 'double') -> "double":
	return _npstat.ContOrthoPoly1D_series(self, coeffs, maxdeg, x)

	def weightCoeffs(self, coeffs: 'double *', maxdeg: 'unsigned int') -> "void":
	return _npstat.ContOrthoPoly1D_weightCoeffs(self, coeffs, maxdeg)

	def empiricalKroneckerDelta(self, deg1: 'unsigned int', deg2: 'unsigned int') -> "double":
	return _npstat.ContOrthoPoly1D_empiricalKroneckerDelta(self, deg1, deg2)

	def empiricalKroneckerCovariance(self, deg1: 'unsigned int', deg2: 'unsigned int', deg3: 'unsigned int', deg4: 'unsigned int') -> "double":
	return _npstat.ContOrthoPoly1D_empiricalKroneckerCovariance(self, deg1, deg2, deg3, deg4)

	def recurrenceCoeffs(self, deg: 'unsigned int') -> "std::pair< double,double >":
	return _npstat.ContOrthoPoly1D_recurrenceCoeffs(self, deg)

	def jacobiMatrix(self, n: 'unsigned int') -> "npstat::Matrix< double >":
	return _npstat.ContOrthoPoly1D_jacobiMatrix(self, n)

	def calculateRoots(self, roots: 'double *', degree: 'unsigned int') -> "void":
	return _npstat.ContOrthoPoly1D_calculateRoots(self, roots, degree)

	def integratePoly(self, degree: 'unsigned int', power: 'unsigned int', xmin: 'double', xmax: 'double') -> "double":
	return _npstat.ContOrthoPoly1D_integratePoly(self, degree, power, xmin, xmax)

	def integrateTripleProduct(self, deg1: 'unsigned int', deg2: 'unsigned int', deg3: 'unsigned int', xmin: 'double', xmax: 'double') -> "double":
	return _npstat.ContOrthoPoly1D_integrateTripleProduct(self, deg1, deg2, deg3, xmin, xmax)

	def powerAverage(self, deg: 'unsigned int', power: 'unsigned int') -> "double":
	return _npstat.ContOrthoPoly1D_powerAverage(self, deg, power)

	def jointPowerAverage(self, deg1: 'unsigned int', power1: 'unsigned int', deg2: 'unsigned int', power2: 'unsigned int') -> "double":
	return _npstat.ContOrthoPoly1D_jointPowerAverage(self, deg1, power1, deg2, power2)

	def jointAverage(self, degrees: 'unsigned int const *', nDegrees: 'unsigned int', degreesSortedIncreasingOrder: 'bool'=False) -> "double":
	return _npstat.ContOrthoPoly1D_jointAverage(self, degrees, nDegrees, degreesSortedIncreasingOrder)

	def cachedJointAverage(self, *args) -> "double":
	return _npstat.ContOrthoPoly1D_cachedJointAverage(self, *args)

	def cov4(self, a: 'unsigned int', b: 'unsigned int', c: 'unsigned int', d: 'unsigned int') -> "double":
	return _npstat.ContOrthoPoly1D_cov4(self, a, b, c, d)

	def cov6(self, a: 'unsigned int', b: 'unsigned int', c: 'unsigned int', d: 'unsigned int', e: 'unsigned int', f: 'unsigned int') -> "double":
	return _npstat.ContOrthoPoly1D_cov6(self, a, b, c, d, e, f)

	def cov8(self, a: 'unsigned int', b: 'unsigned int', c: 'unsigned int', d: 'unsigned int', e: 'unsigned int', f: 'unsigned int', g: 'unsigned int', h: 'unsigned int') -> "double":
	return _npstat.ContOrthoPoly1D_cov8(self, a, b, c, d, e, f, g, h)

	def covCov4(self, a: 'unsigned int', b: 'unsigned int', c: 'unsigned int', d: 'unsigned int', e: 'unsigned int', f: 'unsigned int', g: 'unsigned int', h: 'unsigned int') -> "double":
	return _npstat.ContOrthoPoly1D_covCov4(self, a, b, c, d, e, f, g, h)

	def slowCov8(self, a: 'unsigned int', b: 'unsigned int', c: 'unsigned int', d: 'unsigned int', e: 'unsigned int', f: 'unsigned int', g: 'unsigned int', h: 'unsigned int') -> "double":
	return _npstat.ContOrthoPoly1D_slowCov8(self, a, b, c, d, e, f, g, h)

	def epsExpectation(self, m: 'unsigned int', n: 'unsigned int', highOrder: 'bool') -> "double":
	return _npstat.ContOrthoPoly1D_epsExpectation(self, m, n, highOrder)

	def epsCovariance(self, i: 'unsigned int', j: 'unsigned int', m: 'unsigned int', n: 'unsigned int', highOrder: 'bool') -> "double":
	return _npstat.ContOrthoPoly1D_epsCovariance(self, i, j, m, n, highOrder)
	__swig_destroy__ = _npstat.delete_ContOrthoPoly1D
	__del__ = lambda self: None
	ContOrthoPoly1D_swigregister = _npstat.ContOrthoPoly1D_swigregister
	ContOrthoPoly1D_swigregister(ContOrthoPoly1D)

	class GaussLegendreQuadrature(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, GaussLegendreQuadrature, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, GaussLegendreQuadrature, name)
	__repr__ = _swig_repr

	def __init__(self, npoints: 'unsigned int'):
	this = _npstat.new_GaussLegendreQuadrature(npoints)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def npoints(self) -> "unsigned int":
	return _npstat.GaussLegendreQuadrature_npoints(self)
	if _newclass:
	isAllowed = staticmethod(_npstat.GaussLegendreQuadrature_isAllowed)
	else:
	isAllowed = _npstat.GaussLegendreQuadrature_isAllowed
	if _newclass:
	allowedNPonts = staticmethod(_npstat.GaussLegendreQuadrature_allowedNPonts)
	else:
	allowedNPonts = _npstat.GaussLegendreQuadrature_allowedNPonts
	if _newclass:
	minimalExactRule = staticmethod(_npstat.GaussLegendreQuadrature_minimalExactRule)
	else:
	minimalExactRule = _npstat.GaussLegendreQuadrature_minimalExactRule

	def getAbscissae(self) -> "std::vector< double,std::allocator< double > >":
	return _npstat.GaussLegendreQuadrature_getAbscissae(self)

	def getWeights(self) -> "std::vector< double,std::allocator< double > >":
	return _npstat.GaussLegendreQuadrature_getWeights(self)

	def integrate(self, *args) -> "long double":
	return _npstat.GaussLegendreQuadrature_integrate(self, *args)
	__swig_destroy__ = _npstat.delete_GaussLegendreQuadrature
	__del__ = lambda self: None
	GaussLegendreQuadrature_swigregister = _npstat.GaussLegendreQuadrature_swigregister
	GaussLegendreQuadrature_swigregister(GaussLegendreQuadrature)

	def GaussLegendreQuadrature_isAllowed(npoints: 'unsigned int') -> "bool":
	return _npstat.GaussLegendreQuadrature_isAllowed(npoints)
	GaussLegendreQuadrature_isAllowed = _npstat.GaussLegendreQuadrature_isAllowed

	def GaussLegendreQuadrature_allowedNPonts() -> "std::vector< unsigned int,std::allocator< unsigned int > >":
	return _npstat.GaussLegendreQuadrature_allowedNPonts()
	GaussLegendreQuadrature_allowedNPonts = _npstat.GaussLegendreQuadrature_allowedNPonts

	def GaussLegendreQuadrature_minimalExactRule(polyDegree: 'unsigned int') -> "unsigned int":
	return _npstat.GaussLegendreQuadrature_minimalExactRule(polyDegree)
	GaussLegendreQuadrature_minimalExactRule = _npstat.GaussLegendreQuadrature_minimalExactRule

	class AbsClassicalOrthoPoly1D(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, AbsClassicalOrthoPoly1D, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, AbsClassicalOrthoPoly1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_AbsClassicalOrthoPoly1D
	__del__ = lambda self: None

	def clone(self) -> "npstat::AbsClassicalOrthoPoly1D *":
	return _npstat.AbsClassicalOrthoPoly1D_clone(self)

	def xmin(self) -> "double":
	return _npstat.AbsClassicalOrthoPoly1D_xmin(self)

	def xmax(self) -> "double":
	return _npstat.AbsClassicalOrthoPoly1D_xmax(self)

	def maxDegree(self) -> "unsigned int":
	return _npstat.AbsClassicalOrthoPoly1D_maxDegree(self)

	def twopoly(self, deg1: 'unsigned int', deg2: 'unsigned int', x: 'long double') -> "std::pair< long double,long double >":
	return _npstat.AbsClassicalOrthoPoly1D_twopoly(self, deg1, deg2, x)

	def allpoly(self, x: 'long double', values: 'long double *', maxdeg: 'unsigned int') -> "void":
	return _npstat.AbsClassicalOrthoPoly1D_allpoly(self, x, values, maxdeg)

	def series(self, coeffs: 'double const *', maxdeg: 'unsigned int', x: 'double') -> "double":
	return _npstat.AbsClassicalOrthoPoly1D_series(self, coeffs, maxdeg, x)

	def integratePoly(self, degree: 'unsigned int', power: 'unsigned int') -> "double":
	return _npstat.AbsClassicalOrthoPoly1D_integratePoly(self, degree, power)

	def jointIntegral(self, degrees: 'unsigned int const *', nDegrees: 'unsigned int') -> "double":
	return _npstat.AbsClassicalOrthoPoly1D_jointIntegral(self, degrees, nDegrees)

	def weight(self, x: 'double const') -> "double":
	return _npstat.AbsClassicalOrthoPoly1D_weight(self, x)

	def poly(self, deg: 'unsigned int const', x: 'double const') -> "double":
	return _npstat.AbsClassicalOrthoPoly1D_poly(self, deg, x)

	def empiricalKroneckerDelta(self, quad: 'GaussLegendreQuadrature', deg1: 'unsigned int', deg2: 'unsigned int') -> "double":
	return _npstat.AbsClassicalOrthoPoly1D_empiricalKroneckerDelta(self, quad, deg1, deg2)
	AbsClassicalOrthoPoly1D_swigregister = _npstat.AbsClassicalOrthoPoly1D_swigregister
	AbsClassicalOrthoPoly1D_swigregister(AbsClassicalOrthoPoly1D)

	class OrthoPoly1DWeight(LongDoubleLongDoubleFunctor1):
	__swig_setmethods__ = {}
	for _s in [LongDoubleLongDoubleFunctor1]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, OrthoPoly1DWeight, name, value)
	__swig_getmethods__ = {}
	for _s in [LongDoubleLongDoubleFunctor1]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, OrthoPoly1DWeight, name)
	__repr__ = _swig_repr

	def __init__(self, fcn: 'AbsClassicalOrthoPoly1D', normfactor: 'long double const'=1.0):
	this = _npstat.new_OrthoPoly1DWeight(fcn, normfactor)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_OrthoPoly1DWeight
	__del__ = lambda self: None

	def __call__(self, a: 'long double const &') -> "long double":
	return _npstat.OrthoPoly1DWeight___call__(self, a)
	OrthoPoly1DWeight_swigregister = _npstat.OrthoPoly1DWeight_swigregister
	OrthoPoly1DWeight_swigregister(OrthoPoly1DWeight)

	class OrthoPoly1D(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, OrthoPoly1D, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, OrthoPoly1D, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_OrthoPoly1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_OrthoPoly1D
	__del__ = lambda self: None

	def length(self) -> "unsigned int":
	return _npstat.OrthoPoly1D_length(self)

	def maxDegree(self) -> "unsigned int":
	return _npstat.OrthoPoly1D_maxDegree(self)

	def step(self) -> "double":
	return _npstat.OrthoPoly1D_step(self)

	def __eq__(self, r: 'OrthoPoly1D') -> "bool":
	return _npstat.OrthoPoly1D___eq__(self, r)

	def __ne__(self, r: 'OrthoPoly1D') -> "bool":
	return _npstat.OrthoPoly1D___ne__(self, r)

	def weight(self, index: 'unsigned int') -> "double":
	return _npstat.OrthoPoly1D_weight(self, index)

	def poly(self, deg: 'unsigned int', index: 'unsigned int') -> "double":
	return _npstat.OrthoPoly1D_poly(self, deg, index)

	def polyTimesWeight(self, deg: 'unsigned int', index: 'unsigned int') -> "double":
	return _npstat.OrthoPoly1D_polyTimesWeight(self, deg, index)

	def series(self, coeffs: 'double const *', maxdeg: 'unsigned int', index: 'unsigned int') -> "double":
	return _npstat.OrthoPoly1D_series(self, coeffs, maxdeg, index)

	def calculateCoeffs(self, data: 'double const ', dataLen: 'unsigned int', coeffs: 'double ', maxdeg: 'unsigned int') -> "void":
	return _npstat.OrthoPoly1D_calculateCoeffs(self, data, dataLen, coeffs, maxdeg)

	def empiricalKroneckerDelta(self, deg1: 'unsigned int', deg2: 'unsigned int') -> "double":
	return _npstat.OrthoPoly1D_empiricalKroneckerDelta(self, deg1, deg2)

	def weightExpansionCoeffs(self, coeffs: 'double *', maxdeg: 'unsigned int') -> "void":
	return _npstat.OrthoPoly1D_weightExpansionCoeffs(self, coeffs, maxdeg)

	def weightExpansionCovariance(self, deg1: 'unsigned int', deg2: 'unsigned int') -> "double":
	return _npstat.OrthoPoly1D_weightExpansionCovariance(self, deg1, deg2)

	def unweightedPolyProduct(self, deg1: 'unsigned int', deg2: 'unsigned int') -> "double":
	return _npstat.OrthoPoly1D_unweightedPolyProduct(self, deg1, deg2)

	def linearFilter(self, coeffs: 'double const ', maxdeg: 'unsigned int', index: 'unsigned int', result: 'double ', lenResult: 'unsigned int') -> "void":
	return _npstat.OrthoPoly1D_linearFilter(self, coeffs, maxdeg, index, result, lenResult)
	OrthoPoly1D_swigregister = _npstat.OrthoPoly1D_swigregister
	OrthoPoly1D_swigregister(OrthoPoly1D)

	class LegendreOrthoPoly1D(AbsClassicalOrthoPoly1D):
	__swig_setmethods__ = {}
	for _s in [AbsClassicalOrthoPoly1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, LegendreOrthoPoly1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsClassicalOrthoPoly1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, LegendreOrthoPoly1D, name)
	__repr__ = _swig_repr

	def clone(self) -> "npstat::LegendreOrthoPoly1D *":
	return _npstat.LegendreOrthoPoly1D_clone(self)
	__swig_destroy__ = _npstat.delete_LegendreOrthoPoly1D
	__del__ = lambda self: None

	def xmin(self) -> "double":
	return _npstat.LegendreOrthoPoly1D_xmin(self)

	def xmax(self) -> "double":
	return _npstat.LegendreOrthoPoly1D_xmax(self)

	def __init__(self):
	this = _npstat.new_LegendreOrthoPoly1D()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	LegendreOrthoPoly1D_swigregister = _npstat.LegendreOrthoPoly1D_swigregister
	LegendreOrthoPoly1D_swigregister(LegendreOrthoPoly1D)

	class ShiftedLegendreOrthoPoly1D(AbsClassicalOrthoPoly1D):
	__swig_setmethods__ = {}
	for _s in [AbsClassicalOrthoPoly1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ShiftedLegendreOrthoPoly1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsClassicalOrthoPoly1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ShiftedLegendreOrthoPoly1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr

	def clone(self) -> "npstat::ShiftedLegendreOrthoPoly1D *":
	return _npstat.ShiftedLegendreOrthoPoly1D_clone(self)
	__swig_destroy__ = _npstat.delete_ShiftedLegendreOrthoPoly1D
	__del__ = lambda self: None

	def xmin(self) -> "double":
	return _npstat.ShiftedLegendreOrthoPoly1D_xmin(self)

	def xmax(self) -> "double":
	return _npstat.ShiftedLegendreOrthoPoly1D_xmax(self)
	ShiftedLegendreOrthoPoly1D_swigregister = _npstat.ShiftedLegendreOrthoPoly1D_swigregister
	ShiftedLegendreOrthoPoly1D_swigregister(ShiftedLegendreOrthoPoly1D)

	class JacobiOrthoPoly1D(AbsClassicalOrthoPoly1D):
	__swig_setmethods__ = {}
	for _s in [AbsClassicalOrthoPoly1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, JacobiOrthoPoly1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsClassicalOrthoPoly1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, JacobiOrthoPoly1D, name)
	__repr__ = _swig_repr

	def __init__(self, alpha: 'double', beta: 'double'):
	this = _npstat.new_JacobiOrthoPoly1D(alpha, beta)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def clone(self) -> "npstat::JacobiOrthoPoly1D *":
	return _npstat.JacobiOrthoPoly1D_clone(self)
	__swig_destroy__ = _npstat.delete_JacobiOrthoPoly1D
	__del__ = lambda self: None

	def alpha(self) -> "double":
	return _npstat.JacobiOrthoPoly1D_alpha(self)

	def beta(self) -> "double":
	return _npstat.JacobiOrthoPoly1D_beta(self)

	def xmin(self) -> "double":
	return _npstat.JacobiOrthoPoly1D_xmin(self)

	def xmax(self) -> "double":
	return _npstat.JacobiOrthoPoly1D_xmax(self)
	JacobiOrthoPoly1D_swigregister = _npstat.JacobiOrthoPoly1D_swigregister
	JacobiOrthoPoly1D_swigregister(JacobiOrthoPoly1D)

	class ChebyshevOrthoPoly1st(AbsClassicalOrthoPoly1D):
	__swig_setmethods__ = {}
	for _s in [AbsClassicalOrthoPoly1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ChebyshevOrthoPoly1st, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsClassicalOrthoPoly1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ChebyshevOrthoPoly1st, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr

	def clone(self) -> "npstat::ChebyshevOrthoPoly1st *":
	return _npstat.ChebyshevOrthoPoly1st_clone(self)
	__swig_destroy__ = _npstat.delete_ChebyshevOrthoPoly1st
	__del__ = lambda self: None

	def xmin(self) -> "double":
	return _npstat.ChebyshevOrthoPoly1st_xmin(self)

	def xmax(self) -> "double":
	return _npstat.ChebyshevOrthoPoly1st_xmax(self)
	ChebyshevOrthoPoly1st_swigregister = _npstat.ChebyshevOrthoPoly1st_swigregister
	ChebyshevOrthoPoly1st_swigregister(ChebyshevOrthoPoly1st)

	class ChebyshevOrthoPoly2nd(AbsClassicalOrthoPoly1D):
	__swig_setmethods__ = {}
	for _s in [AbsClassicalOrthoPoly1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ChebyshevOrthoPoly2nd, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsClassicalOrthoPoly1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ChebyshevOrthoPoly2nd, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr

	def clone(self) -> "npstat::ChebyshevOrthoPoly2nd *":
	return _npstat.ChebyshevOrthoPoly2nd_clone(self)
	__swig_destroy__ = _npstat.delete_ChebyshevOrthoPoly2nd
	__del__ = lambda self: None

	def xmin(self) -> "double":
	return _npstat.ChebyshevOrthoPoly2nd_xmin(self)

	def xmax(self) -> "double":
	return _npstat.ChebyshevOrthoPoly2nd_xmax(self)
	ChebyshevOrthoPoly2nd_swigregister = _npstat.ChebyshevOrthoPoly2nd_swigregister
	ChebyshevOrthoPoly2nd_swigregister(ChebyshevOrthoPoly2nd)

	class HermiteProbOrthoPoly1D(AbsClassicalOrthoPoly1D):
	__swig_setmethods__ = {}
	for _s in [AbsClassicalOrthoPoly1D]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, HermiteProbOrthoPoly1D, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsClassicalOrthoPoly1D]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, HermiteProbOrthoPoly1D, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr

	def clone(self) -> "npstat::HermiteProbOrthoPoly1D *":
	return _npstat.HermiteProbOrthoPoly1D_clone(self)
	__swig_destroy__ = _npstat.delete_HermiteProbOrthoPoly1D
	__del__ = lambda self: None

	def xmin(self) -> "double":
	return _npstat.HermiteProbOrthoPoly1D_xmin(self)

	def xmax(self) -> "double":
	return _npstat.HermiteProbOrthoPoly1D_xmax(self)
	HermiteProbOrthoPoly1D_swigregister = _npstat.HermiteProbOrthoPoly1D_swigregister
	HermiteProbOrthoPoly1D_swigregister(HermiteProbOrthoPoly1D)

	class DoubleDoubleAbsArrayProjector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleDoubleAbsArrayProjector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleDoubleAbsArrayProjector, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_DoubleDoubleAbsArrayProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.DoubleDoubleAbsArrayProjector_clear(self)

	def process(self, index: 'unsigned int const *', indexLen: 'unsigned int', linearIndex: 'unsigned long', value: 'double const &') -> "void":
	return _npstat.DoubleDoubleAbsArrayProjector_process(self, index, indexLen, linearIndex, value)

	def result(self) -> "double":
	return _npstat.DoubleDoubleAbsArrayProjector_result(self)
	DoubleDoubleAbsArrayProjector_swigregister = _npstat.DoubleDoubleAbsArrayProjector_swigregister
	DoubleDoubleAbsArrayProjector_swigregister(DoubleDoubleAbsArrayProjector)

	class FloatFloatAbsArrayProjector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatFloatAbsArrayProjector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatFloatAbsArrayProjector, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatFloatAbsArrayProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.FloatFloatAbsArrayProjector_clear(self)

	def process(self, index: 'unsigned int const *', indexLen: 'unsigned int', linearIndex: 'unsigned long', value: 'float const &') -> "void":
	return _npstat.FloatFloatAbsArrayProjector_process(self, index, indexLen, linearIndex, value)

	def result(self) -> "float":
	return _npstat.FloatFloatAbsArrayProjector_result(self)
	FloatFloatAbsArrayProjector_swigregister = _npstat.FloatFloatAbsArrayProjector_swigregister
	FloatFloatAbsArrayProjector_swigregister(FloatFloatAbsArrayProjector)

	class IntIntAbsArrayProjector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntIntAbsArrayProjector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntIntAbsArrayProjector, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_IntIntAbsArrayProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.IntIntAbsArrayProjector_clear(self)

	def process(self, index: 'unsigned int const *', indexLen: 'unsigned int', linearIndex: 'unsigned long', value: 'int const &') -> "void":
	return _npstat.IntIntAbsArrayProjector_process(self, index, indexLen, linearIndex, value)

	def result(self) -> "int":
	return _npstat.IntIntAbsArrayProjector_result(self)
	IntIntAbsArrayProjector_swigregister = _npstat.IntIntAbsArrayProjector_swigregister
	IntIntAbsArrayProjector_swigregister(IntIntAbsArrayProjector)

	class LLongLLongAbsArrayProjector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongLLongAbsArrayProjector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongLLongAbsArrayProjector, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LLongLLongAbsArrayProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.LLongLLongAbsArrayProjector_clear(self)

	def process(self, index: 'unsigned int const *', indexLen: 'unsigned int', linearIndex: 'unsigned long', value: 'long long const &') -> "void":
	return _npstat.LLongLLongAbsArrayProjector_process(self, index, indexLen, linearIndex, value)

	def result(self) -> "long long":
	return _npstat.LLongLLongAbsArrayProjector_result(self)
	LLongLLongAbsArrayProjector_swigregister = _npstat.LLongLLongAbsArrayProjector_swigregister
	LLongLLongAbsArrayProjector_swigregister(LLongLLongAbsArrayProjector)

	class UCharUCharAbsArrayProjector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharUCharAbsArrayProjector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharUCharAbsArrayProjector, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_UCharUCharAbsArrayProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.UCharUCharAbsArrayProjector_clear(self)

	def process(self, index: 'unsigned int const *', indexLen: 'unsigned int', linearIndex: 'unsigned long', value: 'unsigned char const &') -> "void":
	return _npstat.UCharUCharAbsArrayProjector_process(self, index, indexLen, linearIndex, value)

	def result(self) -> "unsigned char":
	return _npstat.UCharUCharAbsArrayProjector_result(self)
	UCharUCharAbsArrayProjector_swigregister = _npstat.UCharUCharAbsArrayProjector_swigregister
	UCharUCharAbsArrayProjector_swigregister(UCharUCharAbsArrayProjector)

	class FloatDoubleAbsArrayProjector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatDoubleAbsArrayProjector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatDoubleAbsArrayProjector, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_FloatDoubleAbsArrayProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.FloatDoubleAbsArrayProjector_clear(self)

	def process(self, index: 'unsigned int const *', indexLen: 'unsigned int', linearIndex: 'unsigned long', value: 'float const &') -> "void":
	return _npstat.FloatDoubleAbsArrayProjector_process(self, index, indexLen, linearIndex, value)

	def result(self) -> "double":
	return _npstat.FloatDoubleAbsArrayProjector_result(self)
	FloatDoubleAbsArrayProjector_swigregister = _npstat.FloatDoubleAbsArrayProjector_swigregister
	FloatDoubleAbsArrayProjector_swigregister(FloatDoubleAbsArrayProjector)

	class IntDoubleAbsArrayProjector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntDoubleAbsArrayProjector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntDoubleAbsArrayProjector, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_IntDoubleAbsArrayProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.IntDoubleAbsArrayProjector_clear(self)

	def process(self, index: 'unsigned int const *', indexLen: 'unsigned int', linearIndex: 'unsigned long', value: 'int const &') -> "void":
	return _npstat.IntDoubleAbsArrayProjector_process(self, index, indexLen, linearIndex, value)

	def result(self) -> "double":
	return _npstat.IntDoubleAbsArrayProjector_result(self)
	IntDoubleAbsArrayProjector_swigregister = _npstat.IntDoubleAbsArrayProjector_swigregister
	IntDoubleAbsArrayProjector_swigregister(IntDoubleAbsArrayProjector)

	class LLongDoubleAbsArrayProjector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongDoubleAbsArrayProjector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongDoubleAbsArrayProjector, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_LLongDoubleAbsArrayProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.LLongDoubleAbsArrayProjector_clear(self)

	def process(self, index: 'unsigned int const *', indexLen: 'unsigned int', linearIndex: 'unsigned long', value: 'long long const &') -> "void":
	return _npstat.LLongDoubleAbsArrayProjector_process(self, index, indexLen, linearIndex, value)

	def result(self) -> "double":
	return _npstat.LLongDoubleAbsArrayProjector_result(self)
	LLongDoubleAbsArrayProjector_swigregister = _npstat.LLongDoubleAbsArrayProjector_swigregister
	LLongDoubleAbsArrayProjector_swigregister(LLongDoubleAbsArrayProjector)

	class UCharDoubleAbsArrayProjector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharDoubleAbsArrayProjector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharDoubleAbsArrayProjector, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_UCharDoubleAbsArrayProjector
	__del__ = lambda self: None

	def clear(self) -> "void":
	return _npstat.UCharDoubleAbsArrayProjector_clear(self)

	def process(self, index: 'unsigned int const *', indexLen: 'unsigned int', linearIndex: 'unsigned long', value: 'unsigned char const &') -> "void":
	return _npstat.UCharDoubleAbsArrayProjector_process(self, index, indexLen, linearIndex, value)

	def result(self) -> "double":
	return _npstat.UCharDoubleAbsArrayProjector_result(self)
	UCharDoubleAbsArrayProjector_swigregister = _npstat.UCharDoubleAbsArrayProjector_swigregister
	UCharDoubleAbsArrayProjector_swigregister(UCharDoubleAbsArrayProjector)

	class ExpMapper1d(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, ExpMapper1d, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, ExpMapper1d, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_ExpMapper1d(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __call__(self, x: 'double const &') -> "double":
	return _npstat.ExpMapper1d___call__(self, x)

	def a(self) -> "double":
	return _npstat.ExpMapper1d_a(self)

	def b(self) -> "double":
	return _npstat.ExpMapper1d_b(self)
	__swig_destroy__ = _npstat.delete_ExpMapper1d
	__del__ = lambda self: None
	ExpMapper1d_swigregister = _npstat.ExpMapper1d_swigregister
	ExpMapper1d_swigregister(ExpMapper1d)

	class ExpMapper1dVector(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, ExpMapper1dVector, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, ExpMapper1dVector, name)
	__repr__ = _swig_repr

	def iterator(self) -> "swig::SwigPyIterator *":
	return _npstat.ExpMapper1dVector_iterator(self)
	def __iter__(self):
	return self.iterator()

	def __nonzero__(self) -> "bool":
	return _npstat.ExpMapper1dVector___nonzero__(self)

	def __bool__(self) -> "bool":
	return _npstat.ExpMapper1dVector___bool__(self)

	def __len__(self) -> "std::vector< npstat::ExpMapper1d >::size_type":
	return _npstat.ExpMapper1dVector___len__(self)

	def __getslice__(self, i: 'std::vector< npstat::ExpMapper1d >::difference_type', j: 'std::vector< npstat::ExpMapper1d >::difference_type') -> "std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > *":
	return _npstat.ExpMapper1dVector___getslice__(self, i, j)

	def __setslice__(self, *args) -> "void":
	return _npstat.ExpMapper1dVector___setslice__(self, *args)

	def __delslice__(self, i: 'std::vector< npstat::ExpMapper1d >::difference_type', j: 'std::vector< npstat::ExpMapper1d >::difference_type') -> "void":
	return _npstat.ExpMapper1dVector___delslice__(self, i, j)

	def __delitem__(self, *args) -> "void":
	return _npstat.ExpMapper1dVector___delitem__(self, *args)

	def __getitem__(self, *args) -> "std::vector< npstat::ExpMapper1d >::value_type const &":
	return _npstat.ExpMapper1dVector___getitem__(self, *args)

	def __setitem__(self, *args) -> "void":
	return _npstat.ExpMapper1dVector___setitem__(self, *args)

	def pop(self) -> "std::vector< npstat::ExpMapper1d >::value_type":
	return _npstat.ExpMapper1dVector_pop(self)

	def append(self, x: 'ExpMapper1d') -> "void":
	return _npstat.ExpMapper1dVector_append(self, x)

	def empty(self) -> "bool":
	return _npstat.ExpMapper1dVector_empty(self)

	def size(self) -> "std::vector< npstat::ExpMapper1d >::size_type":
	return _npstat.ExpMapper1dVector_size(self)

	def swap(self, v: 'ExpMapper1dVector') -> "void":
	return _npstat.ExpMapper1dVector_swap(self, v)

	def begin(self) -> "std::vector< npstat::ExpMapper1d >::iterator":
	return _npstat.ExpMapper1dVector_begin(self)

	def end(self) -> "std::vector< npstat::ExpMapper1d >::iterator":
	return _npstat.ExpMapper1dVector_end(self)

	def rbegin(self) -> "std::vector< npstat::ExpMapper1d >::reverse_iterator":
	return _npstat.ExpMapper1dVector_rbegin(self)

	def rend(self) -> "std::vector< npstat::ExpMapper1d >::reverse_iterator":
	return _npstat.ExpMapper1dVector_rend(self)

	def clear(self) -> "void":
	return _npstat.ExpMapper1dVector_clear(self)

	def get_allocator(self) -> "std::vector< npstat::ExpMapper1d >::allocator_type":
	return _npstat.ExpMapper1dVector_get_allocator(self)

	def pop_back(self) -> "void":
	return _npstat.ExpMapper1dVector_pop_back(self)

	def erase(self, *args) -> "std::vector< npstat::ExpMapper1d >::iterator":
	return _npstat.ExpMapper1dVector_erase(self, *args)

	def __init__(self, *args):
	this = _npstat.new_ExpMapper1dVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def push_back(self, x: 'ExpMapper1d') -> "void":
	return _npstat.ExpMapper1dVector_push_back(self, x)

	def front(self) -> "std::vector< npstat::ExpMapper1d >::value_type const &":
	return _npstat.ExpMapper1dVector_front(self)

	def back(self) -> "std::vector< npstat::ExpMapper1d >::value_type const &":
	return _npstat.ExpMapper1dVector_back(self)

	def assign(self, n: 'std::vector< npstat::ExpMapper1d >::size_type', x: 'ExpMapper1d') -> "void":
	return _npstat.ExpMapper1dVector_assign(self, n, x)

	def resize(self, *args) -> "void":
	return _npstat.ExpMapper1dVector_resize(self, *args)

	def insert(self, *args) -> "void":
	return _npstat.ExpMapper1dVector_insert(self, *args)

	def reserve(self, n: 'std::vector< npstat::ExpMapper1d >::size_type') -> "void":
	return _npstat.ExpMapper1dVector_reserve(self, n)

	def capacity(self) -> "std::vector< npstat::ExpMapper1d >::size_type":
	return _npstat.ExpMapper1dVector_capacity(self)
	__swig_destroy__ = _npstat.delete_ExpMapper1dVector
	__del__ = lambda self: None
	ExpMapper1dVector_swigregister = _npstat.ExpMapper1dVector_swigregister
	ExpMapper1dVector_swigregister(ExpMapper1dVector)


	def rescanArray(*args) -> "void":
	return _npstat.rescanArray(*args)
	rescanArray = _npstat.rescanArray

	def clearBuffer(*args) -> "void":
	return _npstat.clearBuffer(*args)
	clearBuffer = _npstat.clearBuffer

	def copyBuffer(*args) -> "void":
	return _npstat.copyBuffer(*args)
	copyBuffer = _npstat.copyBuffer
	class ConvolutionEngine1D(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, ConvolutionEngine1D, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, ConvolutionEngine1D, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_ConvolutionEngine1D(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ConvolutionEngine1D
	__del__ = lambda self: None

	def discardFilter(self, id: 'unsigned long') -> "bool":
	return _npstat.ConvolutionEngine1D_discardFilter(self, id)

	def dataLength(self) -> "unsigned int":
	return _npstat.ConvolutionEngine1D_dataLength(self)

	def setFilter(self, *args) -> "void":
	return _npstat.ConvolutionEngine1D_setFilter(self, *args)

	def convolveWithFilter(self, *args) -> "void":
	return _npstat.ConvolutionEngine1D_convolveWithFilter(self, *args)

	def depositFilter(self, *args) -> "void":
	return _npstat.ConvolutionEngine1D_depositFilter(self, *args)

	def convolveWithDeposit(self, *args) -> "void":
	return _npstat.ConvolutionEngine1D_convolveWithDeposit(self, *args)
	ConvolutionEngine1D_swigregister = _npstat.ConvolutionEngine1D_swigregister
	ConvolutionEngine1D_swigregister(ConvolutionEngine1D)

	class GaussHermiteQuadrature(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, GaussHermiteQuadrature, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, GaussHermiteQuadrature, name)
	__repr__ = _swig_repr

	def __init__(self, npoints: 'unsigned int'):
	this = _npstat.new_GaussHermiteQuadrature(npoints)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def npoints(self) -> "unsigned int":
	return _npstat.GaussHermiteQuadrature_npoints(self)
	if _newclass:
	isAllowed = staticmethod(_npstat.GaussHermiteQuadrature_isAllowed)
	else:
	isAllowed = _npstat.GaussHermiteQuadrature_isAllowed
	if _newclass:
	allowedNPonts = staticmethod(_npstat.GaussHermiteQuadrature_allowedNPonts)
	else:
	allowedNPonts = _npstat.GaussHermiteQuadrature_allowedNPonts
	if _newclass:
	minimalExactRule = staticmethod(_npstat.GaussHermiteQuadrature_minimalExactRule)
	else:
	minimalExactRule = _npstat.GaussHermiteQuadrature_minimalExactRule

	def getAbscissae(self) -> "std::vector< double,std::allocator< double > >":
	return _npstat.GaussHermiteQuadrature_getAbscissae(self)

	def getWeights(self) -> "std::vector< double,std::allocator< double > >":
	return _npstat.GaussHermiteQuadrature_getWeights(self)

	def integrate(self, fcn: 'DoubleDoubleFunctor1') -> "long double":
	return _npstat.GaussHermiteQuadrature_integrate(self, fcn)
	__swig_destroy__ = _npstat.delete_GaussHermiteQuadrature
	__del__ = lambda self: None
	GaussHermiteQuadrature_swigregister = _npstat.GaussHermiteQuadrature_swigregister
	GaussHermiteQuadrature_swigregister(GaussHermiteQuadrature)

	def GaussHermiteQuadrature_isAllowed(npoints: 'unsigned int') -> "bool":
	return _npstat.GaussHermiteQuadrature_isAllowed(npoints)
	GaussHermiteQuadrature_isAllowed = _npstat.GaussHermiteQuadrature_isAllowed

	def GaussHermiteQuadrature_allowedNPonts() -> "std::vector< unsigned int,std::allocator< unsigned int > >":
	return _npstat.GaussHermiteQuadrature_allowedNPonts()
	GaussHermiteQuadrature_allowedNPonts = _npstat.GaussHermiteQuadrature_allowedNPonts

	def GaussHermiteQuadrature_minimalExactRule(polyDegree: 'unsigned int') -> "unsigned int":
	return _npstat.GaussHermiteQuadrature_minimalExactRule(polyDegree)
	GaussHermiteQuadrature_minimalExactRule = _npstat.GaussHermiteQuadrature_minimalExactRule

	class FejerQuadrature(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FejerQuadrature, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FejerQuadrature, name)
	__repr__ = _swig_repr

	def __init__(self, npoints: 'unsigned int'):
	this = _npstat.new_FejerQuadrature(npoints)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def npoints(self) -> "unsigned int":
	return _npstat.FejerQuadrature_npoints(self)
	if _newclass:
	minimalExactRule = staticmethod(_npstat.FejerQuadrature_minimalExactRule)
	else:
	minimalExactRule = _npstat.FejerQuadrature_minimalExactRule

	def getAbscissae(self) -> "std::vector< double,std::allocator< double > >":
	return _npstat.FejerQuadrature_getAbscissae(self)

	def getWeights(self) -> "std::vector< double,std::allocator< double > >":
	return _npstat.FejerQuadrature_getWeights(self)

	def integrate(self, fcn: 'DoubleDoubleFunctor1', a: 'long double', b: 'long double') -> "long double":
	return _npstat.FejerQuadrature_integrate(self, fcn, a, b)
	__swig_destroy__ = _npstat.delete_FejerQuadrature
	__del__ = lambda self: None
	FejerQuadrature_swigregister = _npstat.FejerQuadrature_swigregister
	FejerQuadrature_swigregister(FejerQuadrature)

	def FejerQuadrature_minimalExactRule(polyDegree: 'unsigned int') -> "unsigned int":
	return _npstat.FejerQuadrature_minimalExactRule(polyDegree)
	FejerQuadrature_minimalExactRule = _npstat.FejerQuadrature_minimalExactRule

	class UCharBoxNDScanner(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, UCharBoxNDScanner, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, UCharBoxNDScanner, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_UCharBoxNDScanner(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.UCharBoxNDScanner_dim(self)

	def state(self) -> "unsigned long":
	return _npstat.UCharBoxNDScanner_state(self)

	def maxState(self) -> "unsigned long":
	return _npstat.UCharBoxNDScanner_maxState(self)

	def isValid(self) -> "bool":
	return _npstat.UCharBoxNDScanner_isValid(self)

	def getCoords(self, x: 'unsigned char *', nx: 'unsigned int') -> "void":
	return _npstat.UCharBoxNDScanner_getCoords(self, x, nx)

	def getIndex(self, index: 'unsigned int *', indexBufferLen: 'unsigned int') -> "void":
	return _npstat.UCharBoxNDScanner_getIndex(self, index, indexBufferLen)

	def reset(self) -> "void":
	return _npstat.UCharBoxNDScanner_reset(self)

	def setState(self, state: 'unsigned long const') -> "void":
	return _npstat.UCharBoxNDScanner_setState(self, state)
	__swig_destroy__ = _npstat.delete_UCharBoxNDScanner
	__del__ = lambda self: None
	UCharBoxNDScanner_swigregister = _npstat.UCharBoxNDScanner_swigregister
	UCharBoxNDScanner_swigregister(UCharBoxNDScanner)

	class IntBoxNDScanner(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, IntBoxNDScanner, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, IntBoxNDScanner, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_IntBoxNDScanner(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.IntBoxNDScanner_dim(self)

	def state(self) -> "unsigned long":
	return _npstat.IntBoxNDScanner_state(self)

	def maxState(self) -> "unsigned long":
	return _npstat.IntBoxNDScanner_maxState(self)

	def isValid(self) -> "bool":
	return _npstat.IntBoxNDScanner_isValid(self)

	def getCoords(self, x: 'int *', nx: 'unsigned int') -> "void":
	return _npstat.IntBoxNDScanner_getCoords(self, x, nx)

	def getIndex(self, index: 'unsigned int *', indexBufferLen: 'unsigned int') -> "void":
	return _npstat.IntBoxNDScanner_getIndex(self, index, indexBufferLen)

	def reset(self) -> "void":
	return _npstat.IntBoxNDScanner_reset(self)

	def setState(self, state: 'unsigned long const') -> "void":
	return _npstat.IntBoxNDScanner_setState(self, state)
	__swig_destroy__ = _npstat.delete_IntBoxNDScanner
	__del__ = lambda self: None
	IntBoxNDScanner_swigregister = _npstat.IntBoxNDScanner_swigregister
	IntBoxNDScanner_swigregister(IntBoxNDScanner)

	class LLongBoxNDScanner(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, LLongBoxNDScanner, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, LLongBoxNDScanner, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_LLongBoxNDScanner(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.LLongBoxNDScanner_dim(self)

	def state(self) -> "unsigned long":
	return _npstat.LLongBoxNDScanner_state(self)

	def maxState(self) -> "unsigned long":
	return _npstat.LLongBoxNDScanner_maxState(self)

	def isValid(self) -> "bool":
	return _npstat.LLongBoxNDScanner_isValid(self)

	def getCoords(self, x: 'long long *', nx: 'unsigned int') -> "void":
	return _npstat.LLongBoxNDScanner_getCoords(self, x, nx)

	def getIndex(self, index: 'unsigned int *', indexBufferLen: 'unsigned int') -> "void":
	return _npstat.LLongBoxNDScanner_getIndex(self, index, indexBufferLen)

	def reset(self) -> "void":
	return _npstat.LLongBoxNDScanner_reset(self)

	def setState(self, state: 'unsigned long const') -> "void":
	return _npstat.LLongBoxNDScanner_setState(self, state)
	__swig_destroy__ = _npstat.delete_LLongBoxNDScanner
	__del__ = lambda self: None
	LLongBoxNDScanner_swigregister = _npstat.LLongBoxNDScanner_swigregister
	LLongBoxNDScanner_swigregister(LLongBoxNDScanner)

	class FloatBoxNDScanner(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, FloatBoxNDScanner, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, FloatBoxNDScanner, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_FloatBoxNDScanner(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.FloatBoxNDScanner_dim(self)

	def state(self) -> "unsigned long":
	return _npstat.FloatBoxNDScanner_state(self)

	def maxState(self) -> "unsigned long":
	return _npstat.FloatBoxNDScanner_maxState(self)

	def isValid(self) -> "bool":
	return _npstat.FloatBoxNDScanner_isValid(self)

	def getCoords(self, x: 'float *', nx: 'unsigned int') -> "void":
	return _npstat.FloatBoxNDScanner_getCoords(self, x, nx)

	def getIndex(self, index: 'unsigned int *', indexBufferLen: 'unsigned int') -> "void":
	return _npstat.FloatBoxNDScanner_getIndex(self, index, indexBufferLen)

	def reset(self) -> "void":
	return _npstat.FloatBoxNDScanner_reset(self)

	def setState(self, state: 'unsigned long const') -> "void":
	return _npstat.FloatBoxNDScanner_setState(self, state)
	__swig_destroy__ = _npstat.delete_FloatBoxNDScanner
	__del__ = lambda self: None
	FloatBoxNDScanner_swigregister = _npstat.FloatBoxNDScanner_swigregister
	FloatBoxNDScanner_swigregister(FloatBoxNDScanner)

	class DoubleBoxNDScanner(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, DoubleBoxNDScanner, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, DoubleBoxNDScanner, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_DoubleBoxNDScanner(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def dim(self) -> "unsigned int":
	return _npstat.DoubleBoxNDScanner_dim(self)

	def state(self) -> "unsigned long":
	return _npstat.DoubleBoxNDScanner_state(self)

	def maxState(self) -> "unsigned long":
	return _npstat.DoubleBoxNDScanner_maxState(self)

	def isValid(self) -> "bool":
	return _npstat.DoubleBoxNDScanner_isValid(self)

	def getCoords(self, x: 'double *', nx: 'unsigned int') -> "void":
	return _npstat.DoubleBoxNDScanner_getCoords(self, x, nx)

	def getIndex(self, index: 'unsigned int *', indexBufferLen: 'unsigned int') -> "void":
	return _npstat.DoubleBoxNDScanner_getIndex(self, index, indexBufferLen)

	def reset(self) -> "void":
	return _npstat.DoubleBoxNDScanner_reset(self)

	def setState(self, state: 'unsigned long const') -> "void":
	return _npstat.DoubleBoxNDScanner_setState(self, state)
	__swig_destroy__ = _npstat.delete_DoubleBoxNDScanner
	__del__ = lambda self: None
	DoubleBoxNDScanner_swigregister = _npstat.DoubleBoxNDScanner_swigregister
	DoubleBoxNDScanner_swigregister(DoubleBoxNDScanner)

	class ConvolutionEngineND(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, ConvolutionEngineND, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, ConvolutionEngineND, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_ConvolutionEngineND(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ConvolutionEngineND
	__del__ = lambda self: None

	def discardFilter(self, id: 'unsigned long') -> "bool":
	return _npstat.ConvolutionEngineND_discardFilter(self, id)

	def isShapeCompatible(self, dataShape: 'unsigned int const *', rank: 'unsigned int') -> "bool":
	return _npstat.ConvolutionEngineND_isShapeCompatible(self, dataShape, rank)

	def rank(self) -> "unsigned int":
	return _npstat.ConvolutionEngineND_rank(self)

	def shape(self) -> "std::vector< unsigned int,std::allocator< unsigned int > > const &":
	return _npstat.ConvolutionEngineND_shape(self)

	def dataLength(self) -> "unsigned long":
	return _npstat.ConvolutionEngineND_dataLength(self)

	def setFilter(self, *args) -> "void":
	return _npstat.ConvolutionEngineND_setFilter(self, *args)

	def convolveWithFilter(self, *args) -> "void":
	return _npstat.ConvolutionEngineND_convolveWithFilter(self, *args)

	def depositFilter(self, *args) -> "void":
	return _npstat.ConvolutionEngineND_depositFilter(self, *args)

	def convolveWithDeposit(self, *args) -> "void":
	return _npstat.ConvolutionEngineND_convolveWithDeposit(self, *args)
	ConvolutionEngineND_swigregister = _npstat.ConvolutionEngineND_swigregister
	ConvolutionEngineND_swigregister(ConvolutionEngineND)

	class EquidistantInLinearSpace(DoubleVector):
	__swig_setmethods__ = {}
	for _s in [DoubleVector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, EquidistantInLinearSpace, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleVector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, EquidistantInLinearSpace, name)
	__repr__ = _swig_repr

	def __init__(self, minScale: 'double', maxScale: 'double', nScales: 'unsigned int'):
	this = _npstat.new_EquidistantInLinearSpace(minScale, maxScale, nScales)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_EquidistantInLinearSpace
	__del__ = lambda self: None
	EquidistantInLinearSpace_swigregister = _npstat.EquidistantInLinearSpace_swigregister
	EquidistantInLinearSpace_swigregister(EquidistantInLinearSpace)

	class EquidistantInLogSpace(DoubleVector):
	__swig_setmethods__ = {}
	for _s in [DoubleVector]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, EquidistantInLogSpace, name, value)
	__swig_getmethods__ = {}
	for _s in [DoubleVector]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, EquidistantInLogSpace, name)
	__repr__ = _swig_repr

	def __init__(self, minScale: 'double', maxScale: 'double', nScales: 'unsigned int'):
	this = _npstat.new_EquidistantInLogSpace(minScale, maxScale, nScales)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_EquidistantInLogSpace
	__del__ = lambda self: None
	EquidistantInLogSpace_swigregister = _npstat.EquidistantInLogSpace_swigregister
	EquidistantInLogSpace_swigregister(EquidistantInLogSpace)


	def scanKDE1D(distro: 'DoubleKDE1D', xmin: 'double const', xmax: 'double const', npoints: 'unsigned int const', bandwidth: 'double const') -> "PyObject *":
	return _npstat.scanKDE1D(distro, xmin, xmax, npoints, bandwidth)
	scanKDE1D = _npstat.scanKDE1D

	def variableBandwidthSmooth1D(args) -> "PyObject ":
	return _npstat.variableBandwidthSmooth1D(*args)
	variableBandwidthSmooth1D = _npstat.variableBandwidthSmooth1D

	def weightedVariableBandwidthSmooth1D(args) -> "PyObject ":
	return _npstat.weightedVariableBandwidthSmooth1D(*args)
	weightedVariableBandwidthSmooth1D = _npstat.weightedVariableBandwidthSmooth1D

	def simpleVariableBandwidthSmooth1D(args) -> "PyObject ":
	return _npstat.simpleVariableBandwidthSmooth1D(*args)
	simpleVariableBandwidthSmooth1D = _npstat.simpleVariableBandwidthSmooth1D
	class ArchiveValueRecord_SCharVector(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_SCharVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_SCharVector, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'SCharVector', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_SCharVector(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_SCharVector
	__del__ = lambda self: None
	ArchiveValueRecord_SCharVector_swigregister = _npstat.ArchiveValueRecord_SCharVector_swigregister
	ArchiveValueRecord_SCharVector_swigregister(ArchiveValueRecord_SCharVector)


	def NPValueRecord_SCharVector(object: 'SCharVector', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::vector< signed char,std::allocator< signed char > > >":
	return _npstat.NPValueRecord_SCharVector(object, name, category)
	NPValueRecord_SCharVector = _npstat.NPValueRecord_SCharVector
	class Ref_SCharVector(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_SCharVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_SCharVector, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_SCharVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'SCharVector') -> "void":
	return _npstat.Ref_SCharVector_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::vector< signed char,std::allocator< signed char > > *":
	return _npstat.Ref_SCharVector_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::vector< signed char,std::allocator< signed char > >":
	return _npstat.Ref_SCharVector_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_SCharVector
	__del__ = lambda self: None
	Ref_SCharVector_swigregister = _npstat.Ref_SCharVector_swigregister
	Ref_SCharVector_swigregister(Ref_SCharVector)

	class ArchiveValueRecord_UCharVector(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_UCharVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_UCharVector, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'UCharVector', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_UCharVector(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_UCharVector
	__del__ = lambda self: None
	ArchiveValueRecord_UCharVector_swigregister = _npstat.ArchiveValueRecord_UCharVector_swigregister
	ArchiveValueRecord_UCharVector_swigregister(ArchiveValueRecord_UCharVector)


	def NPValueRecord_UCharVector(object: 'UCharVector', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::vector< unsigned char,std::allocator< unsigned char > > >":
	return _npstat.NPValueRecord_UCharVector(object, name, category)
	NPValueRecord_UCharVector = _npstat.NPValueRecord_UCharVector
	class Ref_UCharVector(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_UCharVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_UCharVector, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_UCharVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'UCharVector') -> "void":
	return _npstat.Ref_UCharVector_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::vector< unsigned char,std::allocator< unsigned char > > *":
	return _npstat.Ref_UCharVector_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::vector< unsigned char,std::allocator< unsigned char > >":
	return _npstat.Ref_UCharVector_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_UCharVector
	__del__ = lambda self: None
	Ref_UCharVector_swigregister = _npstat.Ref_UCharVector_swigregister
	Ref_UCharVector_swigregister(Ref_UCharVector)

	class ArchiveValueRecord_ShortVector(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_ShortVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_ShortVector, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'ShortVector', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_ShortVector(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_ShortVector
	__del__ = lambda self: None
	ArchiveValueRecord_ShortVector_swigregister = _npstat.ArchiveValueRecord_ShortVector_swigregister
	ArchiveValueRecord_ShortVector_swigregister(ArchiveValueRecord_ShortVector)


	def NPValueRecord_ShortVector(object: 'ShortVector', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::vector< short,std::allocator< short > > >":
	return _npstat.NPValueRecord_ShortVector(object, name, category)
	NPValueRecord_ShortVector = _npstat.NPValueRecord_ShortVector
	class Ref_ShortVector(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_ShortVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_ShortVector, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_ShortVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'ShortVector') -> "void":
	return _npstat.Ref_ShortVector_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::vector< short,std::allocator< short > > *":
	return _npstat.Ref_ShortVector_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::vector< short,std::allocator< short > >":
	return _npstat.Ref_ShortVector_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_ShortVector
	__del__ = lambda self: None
	Ref_ShortVector_swigregister = _npstat.Ref_ShortVector_swigregister
	Ref_ShortVector_swigregister(Ref_ShortVector)

	class ArchiveValueRecord_UShortVector(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_UShortVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_UShortVector, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'UShortVector', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_UShortVector(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_UShortVector
	__del__ = lambda self: None
	ArchiveValueRecord_UShortVector_swigregister = _npstat.ArchiveValueRecord_UShortVector_swigregister
	ArchiveValueRecord_UShortVector_swigregister(ArchiveValueRecord_UShortVector)


	def NPValueRecord_UShortVector(object: 'UShortVector', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::vector< unsigned short,std::allocator< unsigned short > > >":
	return _npstat.NPValueRecord_UShortVector(object, name, category)
	NPValueRecord_UShortVector = _npstat.NPValueRecord_UShortVector
	class Ref_UShortVector(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_UShortVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_UShortVector, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_UShortVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'UShortVector') -> "void":
	return _npstat.Ref_UShortVector_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::vector< unsigned short,std::allocator< unsigned short > > *":
	return _npstat.Ref_UShortVector_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::vector< unsigned short,std::allocator< unsigned short > >":
	return _npstat.Ref_UShortVector_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_UShortVector
	__del__ = lambda self: None
	Ref_UShortVector_swigregister = _npstat.Ref_UShortVector_swigregister
	Ref_UShortVector_swigregister(Ref_UShortVector)

	class ArchiveValueRecord_LongVector(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_LongVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_LongVector, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'LongVector', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_LongVector(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_LongVector
	__del__ = lambda self: None
	ArchiveValueRecord_LongVector_swigregister = _npstat.ArchiveValueRecord_LongVector_swigregister
	ArchiveValueRecord_LongVector_swigregister(ArchiveValueRecord_LongVector)


	def NPValueRecord_LongVector(object: 'LongVector', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::vector< long,std::allocator< long > > >":
	return _npstat.NPValueRecord_LongVector(object, name, category)
	NPValueRecord_LongVector = _npstat.NPValueRecord_LongVector
	class Ref_LongVector(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_LongVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_LongVector, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_LongVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'LongVector') -> "void":
	return _npstat.Ref_LongVector_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::vector< long,std::allocator< long > > *":
	return _npstat.Ref_LongVector_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::vector< long,std::allocator< long > >":
	return _npstat.Ref_LongVector_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_LongVector
	__del__ = lambda self: None
	Ref_LongVector_swigregister = _npstat.Ref_LongVector_swigregister
	Ref_LongVector_swigregister(Ref_LongVector)

	class ArchiveValueRecord_ULongVector(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_ULongVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_ULongVector, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'ULongVector', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_ULongVector(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_ULongVector
	__del__ = lambda self: None
	ArchiveValueRecord_ULongVector_swigregister = _npstat.ArchiveValueRecord_ULongVector_swigregister
	ArchiveValueRecord_ULongVector_swigregister(ArchiveValueRecord_ULongVector)


	def NPValueRecord_ULongVector(object: 'ULongVector', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::vector< unsigned long,std::allocator< unsigned long > > >":
	return _npstat.NPValueRecord_ULongVector(object, name, category)
	NPValueRecord_ULongVector = _npstat.NPValueRecord_ULongVector
	class Ref_ULongVector(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_ULongVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_ULongVector, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_ULongVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'ULongVector') -> "void":
	return _npstat.Ref_ULongVector_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::vector< unsigned long,std::allocator< unsigned long > > *":
	return _npstat.Ref_ULongVector_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::vector< unsigned long,std::allocator< unsigned long > >":
	return _npstat.Ref_ULongVector_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_ULongVector
	__del__ = lambda self: None
	Ref_ULongVector_swigregister = _npstat.Ref_ULongVector_swigregister
	Ref_ULongVector_swigregister(Ref_ULongVector)

	class ArchiveValueRecord_IntVector(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_IntVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_IntVector, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'IntVector', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_IntVector(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_IntVector
	__del__ = lambda self: None
	ArchiveValueRecord_IntVector_swigregister = _npstat.ArchiveValueRecord_IntVector_swigregister
	ArchiveValueRecord_IntVector_swigregister(ArchiveValueRecord_IntVector)


	def NPValueRecord_IntVector(object: 'IntVector', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::vector< int,std::allocator< int > > >":
	return _npstat.NPValueRecord_IntVector(object, name, category)
	NPValueRecord_IntVector = _npstat.NPValueRecord_IntVector
	class Ref_IntVector(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_IntVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_IntVector, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_IntVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'IntVector') -> "void":
	return _npstat.Ref_IntVector_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::vector< int,std::allocator< int > > *":
	return _npstat.Ref_IntVector_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::vector< int,std::allocator< int > >":
	return _npstat.Ref_IntVector_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_IntVector
	__del__ = lambda self: None
	Ref_IntVector_swigregister = _npstat.Ref_IntVector_swigregister
	Ref_IntVector_swigregister(Ref_IntVector)

	class ArchiveValueRecord_LLongVector(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_LLongVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_LLongVector, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'LLongVector', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_LLongVector(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_LLongVector
	__del__ = lambda self: None
	ArchiveValueRecord_LLongVector_swigregister = _npstat.ArchiveValueRecord_LLongVector_swigregister
	ArchiveValueRecord_LLongVector_swigregister(ArchiveValueRecord_LLongVector)


	def NPValueRecord_LLongVector(object: 'LLongVector', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::vector< long long,std::allocator< long long > > >":
	return _npstat.NPValueRecord_LLongVector(object, name, category)
	NPValueRecord_LLongVector = _npstat.NPValueRecord_LLongVector
	class Ref_LLongVector(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_LLongVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_LLongVector, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_LLongVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'LLongVector') -> "void":
	return _npstat.Ref_LLongVector_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::vector< long long,std::allocator< long long > > *":
	return _npstat.Ref_LLongVector_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::vector< long long,std::allocator< long long > >":
	return _npstat.Ref_LLongVector_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_LLongVector
	__del__ = lambda self: None
	Ref_LLongVector_swigregister = _npstat.Ref_LLongVector_swigregister
	Ref_LLongVector_swigregister(Ref_LLongVector)

	class ArchiveValueRecord_UIntVector(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_UIntVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_UIntVector, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'UIntVector', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_UIntVector(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_UIntVector
	__del__ = lambda self: None
	ArchiveValueRecord_UIntVector_swigregister = _npstat.ArchiveValueRecord_UIntVector_swigregister
	ArchiveValueRecord_UIntVector_swigregister(ArchiveValueRecord_UIntVector)


	def NPValueRecord_UIntVector(object: 'UIntVector', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::vector< unsigned int,std::allocator< unsigned int > > >":
	return _npstat.NPValueRecord_UIntVector(object, name, category)
	NPValueRecord_UIntVector = _npstat.NPValueRecord_UIntVector
	class Ref_UIntVector(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_UIntVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_UIntVector, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_UIntVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'UIntVector') -> "void":
	return _npstat.Ref_UIntVector_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::vector< unsigned int,std::allocator< unsigned int > > *":
	return _npstat.Ref_UIntVector_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::vector< unsigned int,std::allocator< unsigned int > >":
	return _npstat.Ref_UIntVector_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_UIntVector
	__del__ = lambda self: None
	Ref_UIntVector_swigregister = _npstat.Ref_UIntVector_swigregister
	Ref_UIntVector_swigregister(Ref_UIntVector)

	class ArchiveValueRecord_ULLongVector(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_ULLongVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_ULLongVector, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'ULLongVector', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_ULLongVector(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_ULLongVector
	__del__ = lambda self: None
	ArchiveValueRecord_ULLongVector_swigregister = _npstat.ArchiveValueRecord_ULLongVector_swigregister
	ArchiveValueRecord_ULLongVector_swigregister(ArchiveValueRecord_ULLongVector)


	def NPValueRecord_ULLongVector(object: 'ULLongVector', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::vector< unsigned long long,std::allocator< unsigned long long > > >":
	return _npstat.NPValueRecord_ULLongVector(object, name, category)
	NPValueRecord_ULLongVector = _npstat.NPValueRecord_ULLongVector
	class Ref_ULLongVector(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_ULLongVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_ULLongVector, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_ULLongVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'ULLongVector') -> "void":
	return _npstat.Ref_ULLongVector_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::vector< unsigned long long,std::allocator< unsigned long long > > *":
	return _npstat.Ref_ULLongVector_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::vector< unsigned long long,std::allocator< unsigned long long > >":
	return _npstat.Ref_ULLongVector_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_ULLongVector
	__del__ = lambda self: None
	Ref_ULLongVector_swigregister = _npstat.Ref_ULLongVector_swigregister
	Ref_ULLongVector_swigregister(Ref_ULLongVector)

	class ArchiveValueRecord_FloatVector(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_FloatVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_FloatVector, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'FloatVector', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_FloatVector(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_FloatVector
	__del__ = lambda self: None
	ArchiveValueRecord_FloatVector_swigregister = _npstat.ArchiveValueRecord_FloatVector_swigregister
	ArchiveValueRecord_FloatVector_swigregister(ArchiveValueRecord_FloatVector)


	def NPValueRecord_FloatVector(object: 'FloatVector', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::vector< float,std::allocator< float > > >":
	return _npstat.NPValueRecord_FloatVector(object, name, category)
	NPValueRecord_FloatVector = _npstat.NPValueRecord_FloatVector
	class Ref_FloatVector(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_FloatVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_FloatVector, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_FloatVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'FloatVector') -> "void":
	return _npstat.Ref_FloatVector_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::vector< float,std::allocator< float > > *":
	return _npstat.Ref_FloatVector_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::vector< float,std::allocator< float > >":
	return _npstat.Ref_FloatVector_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_FloatVector
	__del__ = lambda self: None
	Ref_FloatVector_swigregister = _npstat.Ref_FloatVector_swigregister
	Ref_FloatVector_swigregister(Ref_FloatVector)

	class ArchiveValueRecord_DoubleVector(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_DoubleVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_DoubleVector, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'DoubleVector', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_DoubleVector(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_DoubleVector
	__del__ = lambda self: None
	ArchiveValueRecord_DoubleVector_swigregister = _npstat.ArchiveValueRecord_DoubleVector_swigregister
	ArchiveValueRecord_DoubleVector_swigregister(ArchiveValueRecord_DoubleVector)


	def NPValueRecord_DoubleVector(object: 'DoubleVector', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::vector< double,std::allocator< double > > >":
	return _npstat.NPValueRecord_DoubleVector(object, name, category)
	NPValueRecord_DoubleVector = _npstat.NPValueRecord_DoubleVector
	class Ref_DoubleVector(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_DoubleVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_DoubleVector, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_DoubleVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'DoubleVector') -> "void":
	return _npstat.Ref_DoubleVector_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::vector< double,std::allocator< double > > *":
	return _npstat.Ref_DoubleVector_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::vector< double,std::allocator< double > >":
	return _npstat.Ref_DoubleVector_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_DoubleVector
	__del__ = lambda self: None
	Ref_DoubleVector_swigregister = _npstat.Ref_DoubleVector_swigregister
	Ref_DoubleVector_swigregister(Ref_DoubleVector)

	class ArchiveValueRecord_LDoubleVector(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_LDoubleVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_LDoubleVector, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'LDoubleVector', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_LDoubleVector(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_LDoubleVector
	__del__ = lambda self: None
	ArchiveValueRecord_LDoubleVector_swigregister = _npstat.ArchiveValueRecord_LDoubleVector_swigregister
	ArchiveValueRecord_LDoubleVector_swigregister(ArchiveValueRecord_LDoubleVector)


	def NPValueRecord_LDoubleVector(object: 'LDoubleVector', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::vector< long double,std::allocator< long double > > >":
	return _npstat.NPValueRecord_LDoubleVector(object, name, category)
	NPValueRecord_LDoubleVector = _npstat.NPValueRecord_LDoubleVector
	class Ref_LDoubleVector(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_LDoubleVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_LDoubleVector, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_LDoubleVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'LDoubleVector') -> "void":
	return _npstat.Ref_LDoubleVector_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::vector< long double,std::allocator< long double > > *":
	return _npstat.Ref_LDoubleVector_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::vector< long double,std::allocator< long double > >":
	return _npstat.Ref_LDoubleVector_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_LDoubleVector
	__del__ = lambda self: None
	Ref_LDoubleVector_swigregister = _npstat.Ref_LDoubleVector_swigregister
	Ref_LDoubleVector_swigregister(Ref_LDoubleVector)

	class ArchiveValueRecord_CFloatVector(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_CFloatVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_CFloatVector, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'CFloatVector', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_CFloatVector(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_CFloatVector
	__del__ = lambda self: None
	ArchiveValueRecord_CFloatVector_swigregister = _npstat.ArchiveValueRecord_CFloatVector_swigregister
	ArchiveValueRecord_CFloatVector_swigregister(ArchiveValueRecord_CFloatVector)


	def NPValueRecord_CFloatVector(object: 'CFloatVector', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::vector< std::complex< float >,std::allocator< std::complex< float > > > >":
	return _npstat.NPValueRecord_CFloatVector(object, name, category)
	NPValueRecord_CFloatVector = _npstat.NPValueRecord_CFloatVector
	class Ref_CFloatVector(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_CFloatVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_CFloatVector, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_CFloatVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'CFloatVector') -> "void":
	return _npstat.Ref_CFloatVector_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::vector< std::complex< float >,std::allocator< std::complex< float > > > *":
	return _npstat.Ref_CFloatVector_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::vector< std::complex< float >,std::allocator< std::complex< float > > >":
	return _npstat.Ref_CFloatVector_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_CFloatVector
	__del__ = lambda self: None
	Ref_CFloatVector_swigregister = _npstat.Ref_CFloatVector_swigregister
	Ref_CFloatVector_swigregister(Ref_CFloatVector)

	class ArchiveValueRecord_CDoubleVector(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_CDoubleVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_CDoubleVector, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'CDoubleVector', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_CDoubleVector(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_CDoubleVector
	__del__ = lambda self: None
	ArchiveValueRecord_CDoubleVector_swigregister = _npstat.ArchiveValueRecord_CDoubleVector_swigregister
	ArchiveValueRecord_CDoubleVector_swigregister(ArchiveValueRecord_CDoubleVector)


	def NPValueRecord_CDoubleVector(object: 'CDoubleVector', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::vector< std::complex< double >,std::allocator< std::complex< double > > > >":
	return _npstat.NPValueRecord_CDoubleVector(object, name, category)
	NPValueRecord_CDoubleVector = _npstat.NPValueRecord_CDoubleVector
	class Ref_CDoubleVector(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_CDoubleVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_CDoubleVector, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_CDoubleVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'CDoubleVector') -> "void":
	return _npstat.Ref_CDoubleVector_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::vector< std::complex< double >,std::allocator< std::complex< double > > > *":
	return _npstat.Ref_CDoubleVector_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::vector< std::complex< double >,std::allocator< std::complex< double > > >":
	return _npstat.Ref_CDoubleVector_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_CDoubleVector
	__del__ = lambda self: None
	Ref_CDoubleVector_swigregister = _npstat.Ref_CDoubleVector_swigregister
	Ref_CDoubleVector_swigregister(Ref_CDoubleVector)

	class ArchiveValueRecord_CLDoubleVector(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_CLDoubleVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_CLDoubleVector, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'CLDoubleVector', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_CLDoubleVector(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_CLDoubleVector
	__del__ = lambda self: None
	ArchiveValueRecord_CLDoubleVector_swigregister = _npstat.ArchiveValueRecord_CLDoubleVector_swigregister
	ArchiveValueRecord_CLDoubleVector_swigregister(ArchiveValueRecord_CLDoubleVector)


	def NPValueRecord_CLDoubleVector(object: 'CLDoubleVector', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > >":
	return _npstat.NPValueRecord_CLDoubleVector(object, name, category)
	NPValueRecord_CLDoubleVector = _npstat.NPValueRecord_CLDoubleVector
	class Ref_CLDoubleVector(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_CLDoubleVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_CLDoubleVector, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_CLDoubleVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'CLDoubleVector') -> "void":
	return _npstat.Ref_CLDoubleVector_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > *":
	return _npstat.Ref_CLDoubleVector_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::vector< std::complex< long double >,std::allocator< std::complex< long double > > >":
	return _npstat.Ref_CLDoubleVector_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_CLDoubleVector
	__del__ = lambda self: None
	Ref_CLDoubleVector_swigregister = _npstat.Ref_CLDoubleVector_swigregister
	Ref_CLDoubleVector_swigregister(Ref_CLDoubleVector)

	class ArchiveValueRecord_StringVector(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_StringVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_StringVector, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'StringVector', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_StringVector(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_StringVector
	__del__ = lambda self: None
	ArchiveValueRecord_StringVector_swigregister = _npstat.ArchiveValueRecord_StringVector_swigregister
	ArchiveValueRecord_StringVector_swigregister(ArchiveValueRecord_StringVector)


	def NPValueRecord_StringVector(object: 'StringVector', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::vector< std::string,std::allocator< std::string > > >":
	return _npstat.NPValueRecord_StringVector(object, name, category)
	NPValueRecord_StringVector = _npstat.NPValueRecord_StringVector
	class Ref_StringVector(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_StringVector, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_StringVector, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_StringVector(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'StringVector') -> "void":
	return _npstat.Ref_StringVector_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::vector< std::string,std::allocator< std::string > > *":
	return _npstat.Ref_StringVector_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::vector< std::string,std::allocator< std::string > >":
	return _npstat.Ref_StringVector_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_StringVector
	__del__ = lambda self: None
	Ref_StringVector_swigregister = _npstat.Ref_StringVector_swigregister
	Ref_StringVector_swigregister(Ref_StringVector)


	def histoBars(args) -> "PyObject ":
	return _npstat.histoBars(*args)
	histoBars = _npstat.histoBars

	def histoBars3d(args) -> "PyObject ":
	return _npstat.histoBars3d(*args)
	histoBars3d = _npstat.histoBars3d

	def templateParameters(id: 'ClassId') -> "PyObject *":
	return _npstat.templateParameters(id)
	templateParameters = _npstat.templateParameters

	def arrayNDFromNumpyBool(IN_NUMPYARRAYND: 'bool ') -> "npstat::ArrayND< unsigned char,1U,10U > ":
	return _npstat.arrayNDFromNumpyBool(IN_NUMPYARRAYND)
	arrayNDFromNumpyBool = _npstat.arrayNDFromNumpyBool

	def arrayNDFromNumpyUChar(IN_NUMPYARRAYND: 'unsigned char ') -> "npstat::ArrayND< unsigned char,1U,10U > ":
	return _npstat.arrayNDFromNumpyUChar(IN_NUMPYARRAYND)
	arrayNDFromNumpyUChar = _npstat.arrayNDFromNumpyUChar

	def arrayNDFromNumpyInt(IN_NUMPYARRAYND: 'int ') -> "npstat::ArrayND< int,1U,10U > ":
	return _npstat.arrayNDFromNumpyInt(IN_NUMPYARRAYND)
	arrayNDFromNumpyInt = _npstat.arrayNDFromNumpyInt

	def arrayNDFromNumpyLLong(IN_NUMPYARRAYND: 'long long ') -> "npstat::ArrayND< long long,1U,10U > ":
	return _npstat.arrayNDFromNumpyLLong(IN_NUMPYARRAYND)
	arrayNDFromNumpyLLong = _npstat.arrayNDFromNumpyLLong

	def arrayNDFromNumpyFloat(IN_NUMPYARRAYND: 'float ') -> "npstat::ArrayND< float,1U,10U > ":
	return _npstat.arrayNDFromNumpyFloat(IN_NUMPYARRAYND)
	arrayNDFromNumpyFloat = _npstat.arrayNDFromNumpyFloat

	def arrayNDFromNumpyDouble(IN_NUMPYARRAYND: 'double ') -> "npstat::ArrayND< double,1U,10U > ":
	return _npstat.arrayNDFromNumpyDouble(IN_NUMPYARRAYND)
	arrayNDFromNumpyDouble = _npstat.arrayNDFromNumpyDouble

	def arrayNDFromNumpyCFloat(IN_NUMPYARRAYND: 'std::complex< float > ') -> "npstat::ArrayND< std::complex< float >,1U,10U > ":
	return _npstat.arrayNDFromNumpyCFloat(IN_NUMPYARRAYND)
	arrayNDFromNumpyCFloat = _npstat.arrayNDFromNumpyCFloat

	def arrayNDFromNumpyCDouble(IN_NUMPYARRAYND: 'std::complex< double > ') -> "npstat::ArrayND< std::complex< double >,1U,10U > ":
	return _npstat.arrayNDFromNumpyCDouble(IN_NUMPYARRAYND)
	arrayNDFromNumpyCDouble = _npstat.arrayNDFromNumpyCDouble

	def matrixFromNumpy(IN_NUMPYARRAYND: 'double ') -> "npstat::Matrix< double,16 > ":
	return _npstat.matrixFromNumpy(IN_NUMPYARRAYND)
	matrixFromNumpy = _npstat.matrixFromNumpy

	def histoOutline1D(args) -> "PyObject ":
	return _npstat.histoOutline1D(*args)
	histoOutline1D = _npstat.histoOutline1D

	def histoBinContents1D(args) -> "PyObject ":
	return _npstat.histoBinContents1D(*args)
	histoBinContents1D = _npstat.histoBinContents1D

	def scanDensity1D(distro: 'AbsDistribution1D', xmin: 'double const', xmax: 'double const', npoints: 'unsigned int const') -> "PyObject *":
	return _npstat.scanDensity1D(distro, xmin, xmax, npoints)
	scanDensity1D = _npstat.scanDensity1D
	class StorableNone(_object):
	__swig_setmethods__ = {}
	__setattr__ = lambda self, name, value: _swig_setattr(self, StorableNone, name, value)
	__swig_getmethods__ = {}
	__getattr__ = lambda self, name: _swig_getattr(self, StorableNone, name)
	__repr__ = _swig_repr

	def __init__(self):
	this = _npstat.new_StorableNone()
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def __eq__(self, r: 'StorableNone') -> "bool":
	return _npstat.StorableNone___eq__(self, r)

	def __ne__(self, r: 'StorableNone') -> "bool":
	return _npstat.StorableNone___ne__(self, r)

	def classId(self) -> "gs::ClassId":
	return _npstat.StorableNone_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.StorableNone_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.StorableNone_classname)
	else:
	classname = _npstat.StorableNone_classname
	if _newclass:
	version = staticmethod(_npstat.StorableNone_version)
	else:
	version = _npstat.StorableNone_version
	if _newclass:
	read = staticmethod(_npstat.StorableNone_read)
	else:
	read = _npstat.StorableNone_read
	__swig_destroy__ = _npstat.delete_StorableNone
	__del__ = lambda self: None
	StorableNone_swigregister = _npstat.StorableNone_swigregister
	StorableNone_swigregister(StorableNone)

	def StorableNone_classname() -> "char const *":
	return _npstat.StorableNone_classname()
	StorableNone_classname = _npstat.StorableNone_classname

	def StorableNone_version() -> "unsigned int":
	return _npstat.StorableNone_version()
	StorableNone_version = _npstat.StorableNone_version

	def StorableNone_read(id: 'ClassId', arg3: 'istream') -> "npstat::StorableNone *":
	return _npstat.StorableNone_read(id, arg3)
	StorableNone_read = _npstat.StorableNone_read

	class ArchiveRecord_StorableNone(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_StorableNone, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_StorableNone, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'StorableNone', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_StorableNone(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_StorableNone
	__del__ = lambda self: None
	ArchiveRecord_StorableNone_swigregister = _npstat.ArchiveRecord_StorableNone_swigregister
	ArchiveRecord_StorableNone_swigregister(ArchiveRecord_StorableNone)

	class Ref_StorableNone(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_StorableNone, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_StorableNone, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_StorableNone(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'StorableNone') -> "void":
	return _npstat.Ref_StorableNone_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "npstat::StorableNone *":
	return _npstat.Ref_StorableNone_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "npstat::StorableNone":
	return _npstat.Ref_StorableNone_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_StorableNone
	__del__ = lambda self: None
	Ref_StorableNone_swigregister = _npstat.Ref_StorableNone_swigregister
	Ref_StorableNone_swigregister(Ref_StorableNone)

	class ArchiveValueRecord_StorableNone(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_StorableNone, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_StorableNone, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'StorableNone', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_StorableNone(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_StorableNone
	__del__ = lambda self: None
	ArchiveValueRecord_StorableNone_swigregister = _npstat.ArchiveValueRecord_StorableNone_swigregister
	ArchiveValueRecord_StorableNone_swigregister(ArchiveValueRecord_StorableNone)


	def NPValueRecord_StorableNone(object: 'StorableNone', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< npstat::StorableNone >":
	return _npstat.NPValueRecord_StorableNone(object, name, category)
	NPValueRecord_StorableNone = _npstat.NPValueRecord_StorableNone
	class Ref_PyObject(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_PyObject, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_PyObject, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_PyObject(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_Ref_PyObject
	__del__ = lambda self: None

	def retrieve(self, index: 'unsigned long') -> "PyObject *":
	return _npstat.Ref_PyObject_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "PyObject *":
	return _npstat.Ref_PyObject_getValue(self, index)
	Ref_PyObject_swigregister = _npstat.Ref_PyObject_swigregister
	Ref_PyObject_swigregister(Ref_PyObject)

	class PythonRecord(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, PythonRecord, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, PythonRecord, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_PythonRecord(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_PythonRecord
	__del__ = lambda self: None
	PythonRecord_swigregister = _npstat.PythonRecord_swigregister
	PythonRecord_swigregister(PythonRecord)

	class StringArchive(AbsArchive):
	__swig_setmethods__ = {}
	for _s in [AbsArchive]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, StringArchive, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsArchive]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, StringArchive, name)
	__repr__ = _swig_repr

	def __init__(self, name: 'char const *'=None):
	this = _npstat.new_StringArchive(name)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_StringArchive
	__del__ = lambda self: None

	def isOpen(self) -> "bool":
	return _npstat.StringArchive_isOpen(self)

	def error(self) -> "std::string":
	return _npstat.StringArchive_error(self)

	def isReadable(self) -> "bool":
	return _npstat.StringArchive_isReadable(self)

	def isWritable(self) -> "bool":
	return _npstat.StringArchive_isWritable(self)

	def size(self) -> "unsigned long long":
	return _npstat.StringArchive_size(self)

	def smallestId(self) -> "unsigned long long":
	return _npstat.StringArchive_smallestId(self)

	def largestId(self) -> "unsigned long long":
	return _npstat.StringArchive_largestId(self)

	def idsAreContiguous(self) -> "bool":
	return _npstat.StringArchive_idsAreContiguous(self)

	def itemExists(self, id: 'unsigned long long const') -> "bool":
	return _npstat.StringArchive_itemExists(self, id)

	def itemSearch(self, namePattern: 'SearchSpecifier', categoryPattern: 'SearchSpecifier', idsFound: 'ULLongVector') -> "void":
	return _npstat.StringArchive_itemSearch(self, namePattern, categoryPattern, idsFound)

	def flush(self) -> "void":
	return _npstat.StringArchive_flush(self)

	def str(self) -> "std::string":
	return _npstat.StringArchive_str(self)

	def dataSize(self) -> "unsigned long":
	return _npstat.StringArchive_dataSize(self)

	def classId(self) -> "gs::ClassId":
	return _npstat.StringArchive_classId(self)

	def write(self, of: 'ostream') -> "bool":
	return _npstat.StringArchive_write(self, of)
	if _newclass:
	classname = staticmethod(_npstat.StringArchive_classname)
	else:
	classname = _npstat.StringArchive_classname
	if _newclass:
	version = staticmethod(_npstat.StringArchive_version)
	else:
	version = _npstat.StringArchive_version
	if _newclass:
	read = staticmethod(_npstat.StringArchive_read)
	else:
	read = _npstat.StringArchive_read
	StringArchive_swigregister = _npstat.StringArchive_swigregister
	StringArchive_swigregister(StringArchive)

	def StringArchive_classname() -> "char const *":
	return _npstat.StringArchive_classname()
	StringArchive_classname = _npstat.StringArchive_classname

	def StringArchive_version() -> "unsigned int":
	return _npstat.StringArchive_version()
	StringArchive_version = _npstat.StringArchive_version

	def StringArchive_read(id: 'ClassId', arg3: 'istream') -> "gs::StringArchive *":
	return _npstat.StringArchive_read(id, arg3)
	StringArchive_read = _npstat.StringArchive_read

	class ArchiveRecord_StringArchive(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveRecord_StringArchive, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveRecord_StringArchive, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'StringArchive', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveRecord_StringArchive(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveRecord_StringArchive
	__del__ = lambda self: None
	ArchiveRecord_StringArchive_swigregister = _npstat.ArchiveRecord_StringArchive_swigregister
	ArchiveRecord_StringArchive_swigregister(ArchiveRecord_StringArchive)


	def NPRecord(*args) -> "gs::ArchiveRecord< gs::StringArchive >":
	return _npstat.NPRecord(*args)
	NPRecord = _npstat.NPRecord

	def stringArchiveToBinary(ar: 'StringArchive') -> "PyObject *":
	return _npstat.stringArchiveToBinary(ar)
	stringArchiveToBinary = _npstat.stringArchiveToBinary

	def stringArchiveFromBinary(object: 'PyObject ') -> "gs::StringArchive ":
	return _npstat.stringArchiveFromBinary(object)
	stringArchiveFromBinary = _npstat.stringArchiveFromBinary

	def lorpeSmooth1D(args) -> "PyObject ":
	return _npstat.lorpeSmooth1D(*args)
	lorpeSmooth1D = _npstat.lorpeSmooth1D

	def weightedLorpeSmooth1D(args) -> "PyObject ":
	return _npstat.weightedLorpeSmooth1D(*args)
	weightedLorpeSmooth1D = _npstat.weightedLorpeSmooth1D

	def arrayNDToNumpy(args) -> "PyObject ":
	return _npstat.arrayNDToNumpy(*args)
	arrayNDToNumpy = _npstat.arrayNDToNumpy

	def matrixToNumpy(m: 'DoubleMatrix', copy: 'bool'=True) -> "PyObject *":
	return _npstat.matrixToNumpy(m, copy)
	matrixToNumpy = _npstat.matrixToNumpy
	class BinaryArchiveBase(AbsArchive):
	__swig_setmethods__ = {}
	for _s in [AbsArchive]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, BinaryArchiveBase, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsArchive]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, BinaryArchiveBase, name)

	def __init__(self, args, *kwargs):
	raise AttributeError("No constructor defined - class is abstract")
	__repr__ = _swig_repr
	__swig_destroy__ = _npstat.delete_BinaryArchiveBase
	__del__ = lambda self: None

	def isOpen(self) -> "bool":
	return _npstat.BinaryArchiveBase_isOpen(self)

	def isReadable(self) -> "bool":
	return _npstat.BinaryArchiveBase_isReadable(self)

	def isWritable(self) -> "bool":
	return _npstat.BinaryArchiveBase_isWritable(self)

	def error(self) -> "std::string":
	return _npstat.BinaryArchiveBase_error(self)

	def modeValid(self) -> "bool":
	return _npstat.BinaryArchiveBase_modeValid(self)

	def size(self) -> "unsigned long long":
	return _npstat.BinaryArchiveBase_size(self)

	def smallestId(self) -> "unsigned long long":
	return _npstat.BinaryArchiveBase_smallestId(self)

	def largestId(self) -> "unsigned long long":
	return _npstat.BinaryArchiveBase_largestId(self)

	def idsAreContiguous(self) -> "bool":
	return _npstat.BinaryArchiveBase_idsAreContiguous(self)

	def itemExists(self, id: 'unsigned long long const') -> "bool":
	return _npstat.BinaryArchiveBase_itemExists(self, id)

	def itemSearch(self, namePattern: 'SearchSpecifier', categoryPattern: 'SearchSpecifier', idsFound: 'ULLongVector') -> "void":
	return _npstat.BinaryArchiveBase_itemSearch(self, namePattern, categoryPattern, idsFound)

	def compressionBufferSize(self) -> "std::size_t":
	return _npstat.BinaryArchiveBase_compressionBufferSize(self)

	def compressionLevel(self) -> "int":
	return _npstat.BinaryArchiveBase_compressionLevel(self)

	def minSizeToCompress(self) -> "unsigned int":
	return _npstat.BinaryArchiveBase_minSizeToCompress(self)

	def injectMetadata(self) -> "bool":
	return _npstat.BinaryArchiveBase_injectMetadata(self)
	if _newclass:
	isEmptyFile = staticmethod(_npstat.BinaryArchiveBase_isEmptyFile)
	else:
	isEmptyFile = _npstat.BinaryArchiveBase_isEmptyFile

	def compression(self) -> "int":
	return _npstat.BinaryArchiveBase_compression(self)
	BinaryArchiveBase_swigregister = _npstat.BinaryArchiveBase_swigregister
	BinaryArchiveBase_swigregister(BinaryArchiveBase)

	def BinaryArchiveBase_isEmptyFile(s: 'std::fstream &') -> "bool":
	return _npstat.BinaryArchiveBase_isEmptyFile(s)
	BinaryArchiveBase_isEmptyFile = _npstat.BinaryArchiveBase_isEmptyFile


	def writeStringArchive(ar: 'StringArchive', filename: 'char const *') -> "bool":
	return _npstat.writeStringArchive(ar, filename)
	writeStringArchive = _npstat.writeStringArchive

	def readStringArchive(filename: 'char const ') -> "gs::StringArchive ":
	return _npstat.readStringArchive(filename)
	readStringArchive = _npstat.readStringArchive

	def writeCompressedStringArchive(ar: 'StringArchive', filename: 'char const *', compressionMode: 'unsigned int'=1, compressionLevel: 'int'=-1, minSizeToCompress: 'unsigned int'=1024, bufSize: 'unsigned int'=1048576) -> "bool":
	return _npstat.writeCompressedStringArchive(ar, filename, compressionMode, compressionLevel, minSizeToCompress, bufSize)
	writeCompressedStringArchive = _npstat.writeCompressedStringArchive

	def readCompressedStringArchive(filename: 'char const ') -> "gs::StringArchive ":
	return _npstat.readCompressedStringArchive(filename)
	readCompressedStringArchive = _npstat.readCompressedStringArchive

	def writeCompressedStringArchiveExt(ar: 'StringArchive', filename: 'char const ', suffix: 'char const '=None) -> "bool":
	return _npstat.writeCompressedStringArchiveExt(ar, filename, suffix)
	writeCompressedStringArchiveExt = _npstat.writeCompressedStringArchiveExt

	def readCompressedStringArchiveExt(filename: 'char const ', suffix: 'char const '=None) -> "gs::StringArchive *":
	return _npstat.readCompressedStringArchiveExt(filename, suffix)
	readCompressedStringArchiveExt = _npstat.readCompressedStringArchiveExt

	def loadStringArchiveFromArchive(arch: 'AbsArchive', id: 'unsigned long long') -> "gs::StringArchive *":
	return _npstat.loadStringArchiveFromArchive(arch, id)
	loadStringArchiveFromArchive = _npstat.loadStringArchiveFromArchive
	class ArchiveValueRecord_Bool(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_Bool, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_Bool, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'bool const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_Bool(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_Bool
	__del__ = lambda self: None
	ArchiveValueRecord_Bool_swigregister = _npstat.ArchiveValueRecord_Bool_swigregister
	ArchiveValueRecord_Bool_swigregister(ArchiveValueRecord_Bool)


	def NPValueRecord_Bool(object: 'bool const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< bool >":
	return _npstat.NPValueRecord_Bool(object, name, category)
	NPValueRecord_Bool = _npstat.NPValueRecord_Bool
	class Ref_Bool(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_Bool, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_Bool, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_Bool(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'bool *') -> "void":
	return _npstat.Ref_Bool_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "bool *":
	return _npstat.Ref_Bool_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "bool":
	return _npstat.Ref_Bool_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_Bool
	__del__ = lambda self: None
	Ref_Bool_swigregister = _npstat.Ref_Bool_swigregister
	Ref_Bool_swigregister(Ref_Bool)

	class ArchiveValueRecord_Char(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_Char, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_Char, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'char const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_Char(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_Char
	__del__ = lambda self: None
	ArchiveValueRecord_Char_swigregister = _npstat.ArchiveValueRecord_Char_swigregister
	ArchiveValueRecord_Char_swigregister(ArchiveValueRecord_Char)


	def NPValueRecord_Char(object: 'char const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< char >":
	return _npstat.NPValueRecord_Char(object, name, category)
	NPValueRecord_Char = _npstat.NPValueRecord_Char
	class Ref_Char(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_Char, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_Char, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_Char(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'char *') -> "void":
	return _npstat.Ref_Char_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "char *":
	return _npstat.Ref_Char_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "char":
	return _npstat.Ref_Char_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_Char
	__del__ = lambda self: None
	Ref_Char_swigregister = _npstat.Ref_Char_swigregister
	Ref_Char_swigregister(Ref_Char)

	class ArchiveValueRecord_UChar(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_UChar, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_UChar, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'unsigned char const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_UChar(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_UChar
	__del__ = lambda self: None
	ArchiveValueRecord_UChar_swigregister = _npstat.ArchiveValueRecord_UChar_swigregister
	ArchiveValueRecord_UChar_swigregister(ArchiveValueRecord_UChar)


	def NPValueRecord_UChar(object: 'unsigned char const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< unsigned char >":
	return _npstat.NPValueRecord_UChar(object, name, category)
	NPValueRecord_UChar = _npstat.NPValueRecord_UChar
	class Ref_UChar(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_UChar, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_UChar, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_UChar(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'unsigned char *') -> "void":
	return _npstat.Ref_UChar_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "unsigned char *":
	return _npstat.Ref_UChar_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "unsigned char":
	return _npstat.Ref_UChar_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_UChar
	__del__ = lambda self: None
	Ref_UChar_swigregister = _npstat.Ref_UChar_swigregister
	Ref_UChar_swigregister(Ref_UChar)

	class ArchiveValueRecord_SChar(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_SChar, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_SChar, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'signed char const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_SChar(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_SChar
	__del__ = lambda self: None
	ArchiveValueRecord_SChar_swigregister = _npstat.ArchiveValueRecord_SChar_swigregister
	ArchiveValueRecord_SChar_swigregister(ArchiveValueRecord_SChar)


	def NPValueRecord_SChar(object: 'signed char const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< signed char >":
	return _npstat.NPValueRecord_SChar(object, name, category)
	NPValueRecord_SChar = _npstat.NPValueRecord_SChar
	class Ref_SChar(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_SChar, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_SChar, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_SChar(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'signed char *') -> "void":
	return _npstat.Ref_SChar_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "signed char *":
	return _npstat.Ref_SChar_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "signed char":
	return _npstat.Ref_SChar_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_SChar
	__del__ = lambda self: None
	Ref_SChar_swigregister = _npstat.Ref_SChar_swigregister
	Ref_SChar_swigregister(Ref_SChar)

	class ArchiveValueRecord_Short(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_Short, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_Short, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'short const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_Short(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_Short
	__del__ = lambda self: None
	ArchiveValueRecord_Short_swigregister = _npstat.ArchiveValueRecord_Short_swigregister
	ArchiveValueRecord_Short_swigregister(ArchiveValueRecord_Short)


	def NPValueRecord_Short(object: 'short const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< short >":
	return _npstat.NPValueRecord_Short(object, name, category)
	NPValueRecord_Short = _npstat.NPValueRecord_Short
	class Ref_Short(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_Short, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_Short, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_Short(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'short *') -> "void":
	return _npstat.Ref_Short_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "short *":
	return _npstat.Ref_Short_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "short":
	return _npstat.Ref_Short_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_Short
	__del__ = lambda self: None
	Ref_Short_swigregister = _npstat.Ref_Short_swigregister
	Ref_Short_swigregister(Ref_Short)

	class ArchiveValueRecord_UShort(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_UShort, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_UShort, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'unsigned short const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_UShort(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_UShort
	__del__ = lambda self: None
	ArchiveValueRecord_UShort_swigregister = _npstat.ArchiveValueRecord_UShort_swigregister
	ArchiveValueRecord_UShort_swigregister(ArchiveValueRecord_UShort)


	def NPValueRecord_UShort(object: 'unsigned short const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< unsigned short >":
	return _npstat.NPValueRecord_UShort(object, name, category)
	NPValueRecord_UShort = _npstat.NPValueRecord_UShort
	class Ref_UShort(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_UShort, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_UShort, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_UShort(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'unsigned short *') -> "void":
	return _npstat.Ref_UShort_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "unsigned short *":
	return _npstat.Ref_UShort_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "unsigned short":
	return _npstat.Ref_UShort_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_UShort
	__del__ = lambda self: None
	Ref_UShort_swigregister = _npstat.Ref_UShort_swigregister
	Ref_UShort_swigregister(Ref_UShort)

	class ArchiveValueRecord_Int(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_Int, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_Int, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'int const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_Int(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_Int
	__del__ = lambda self: None
	ArchiveValueRecord_Int_swigregister = _npstat.ArchiveValueRecord_Int_swigregister
	ArchiveValueRecord_Int_swigregister(ArchiveValueRecord_Int)


	def NPValueRecord_Int(object: 'int const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< int >":
	return _npstat.NPValueRecord_Int(object, name, category)
	NPValueRecord_Int = _npstat.NPValueRecord_Int
	class Ref_Int(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_Int, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_Int, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_Int(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'int *') -> "void":
	return _npstat.Ref_Int_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "int *":
	return _npstat.Ref_Int_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "int":
	return _npstat.Ref_Int_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_Int
	__del__ = lambda self: None
	Ref_Int_swigregister = _npstat.Ref_Int_swigregister
	Ref_Int_swigregister(Ref_Int)

	class ArchiveValueRecord_Long(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_Long, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_Long, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'long const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_Long(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_Long
	__del__ = lambda self: None
	ArchiveValueRecord_Long_swigregister = _npstat.ArchiveValueRecord_Long_swigregister
	ArchiveValueRecord_Long_swigregister(ArchiveValueRecord_Long)


	def NPValueRecord_Long(object: 'long const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< long >":
	return _npstat.NPValueRecord_Long(object, name, category)
	NPValueRecord_Long = _npstat.NPValueRecord_Long
	class Ref_Long(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_Long, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_Long, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_Long(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'long *') -> "void":
	return _npstat.Ref_Long_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "long *":
	return _npstat.Ref_Long_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "long":
	return _npstat.Ref_Long_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_Long
	__del__ = lambda self: None
	Ref_Long_swigregister = _npstat.Ref_Long_swigregister
	Ref_Long_swigregister(Ref_Long)

	class ArchiveValueRecord_LLong(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_LLong, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_LLong, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'long long const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_LLong(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_LLong
	__del__ = lambda self: None
	ArchiveValueRecord_LLong_swigregister = _npstat.ArchiveValueRecord_LLong_swigregister
	ArchiveValueRecord_LLong_swigregister(ArchiveValueRecord_LLong)


	def NPValueRecord_LLong(object: 'long long const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< long long >":
	return _npstat.NPValueRecord_LLong(object, name, category)
	NPValueRecord_LLong = _npstat.NPValueRecord_LLong
	class Ref_LLong(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_LLong, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_LLong, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_LLong(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'long long *') -> "void":
	return _npstat.Ref_LLong_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "long long *":
	return _npstat.Ref_LLong_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "long long":
	return _npstat.Ref_LLong_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_LLong
	__del__ = lambda self: None
	Ref_LLong_swigregister = _npstat.Ref_LLong_swigregister
	Ref_LLong_swigregister(Ref_LLong)

	class ArchiveValueRecord_UInt(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_UInt, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_UInt, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'unsigned int const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_UInt(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_UInt
	__del__ = lambda self: None
	ArchiveValueRecord_UInt_swigregister = _npstat.ArchiveValueRecord_UInt_swigregister
	ArchiveValueRecord_UInt_swigregister(ArchiveValueRecord_UInt)


	def NPValueRecord_UInt(object: 'unsigned int const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< unsigned int >":
	return _npstat.NPValueRecord_UInt(object, name, category)
	NPValueRecord_UInt = _npstat.NPValueRecord_UInt
	class Ref_UInt(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_UInt, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_UInt, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_UInt(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'unsigned int *') -> "void":
	return _npstat.Ref_UInt_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "unsigned int *":
	return _npstat.Ref_UInt_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "unsigned int":
	return _npstat.Ref_UInt_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_UInt
	__del__ = lambda self: None
	Ref_UInt_swigregister = _npstat.Ref_UInt_swigregister
	Ref_UInt_swigregister(Ref_UInt)

	class ArchiveValueRecord_ULong(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_ULong, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_ULong, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'unsigned long const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_ULong(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_ULong
	__del__ = lambda self: None
	ArchiveValueRecord_ULong_swigregister = _npstat.ArchiveValueRecord_ULong_swigregister
	ArchiveValueRecord_ULong_swigregister(ArchiveValueRecord_ULong)


	def NPValueRecord_ULong(object: 'unsigned long const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< unsigned long >":
	return _npstat.NPValueRecord_ULong(object, name, category)
	NPValueRecord_ULong = _npstat.NPValueRecord_ULong
	class Ref_ULong(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_ULong, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_ULong, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_ULong(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'unsigned long *') -> "void":
	return _npstat.Ref_ULong_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "unsigned long *":
	return _npstat.Ref_ULong_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "unsigned long":
	return _npstat.Ref_ULong_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_ULong
	__del__ = lambda self: None
	Ref_ULong_swigregister = _npstat.Ref_ULong_swigregister
	Ref_ULong_swigregister(Ref_ULong)

	class ArchiveValueRecord_ULLong(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_ULLong, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_ULLong, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'unsigned long long const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_ULLong(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_ULLong
	__del__ = lambda self: None
	ArchiveValueRecord_ULLong_swigregister = _npstat.ArchiveValueRecord_ULLong_swigregister
	ArchiveValueRecord_ULLong_swigregister(ArchiveValueRecord_ULLong)


	def NPValueRecord_ULLong(object: 'unsigned long long const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< unsigned long long >":
	return _npstat.NPValueRecord_ULLong(object, name, category)
	NPValueRecord_ULLong = _npstat.NPValueRecord_ULLong
	class Ref_ULLong(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_ULLong, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_ULLong, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_ULLong(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'unsigned long long *') -> "void":
	return _npstat.Ref_ULLong_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "unsigned long long *":
	return _npstat.Ref_ULLong_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "unsigned long long":
	return _npstat.Ref_ULLong_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_ULLong
	__del__ = lambda self: None
	Ref_ULLong_swigregister = _npstat.Ref_ULLong_swigregister
	Ref_ULLong_swigregister(Ref_ULLong)

	class ArchiveValueRecord_Float(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_Float, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_Float, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'float const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_Float(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_Float
	__del__ = lambda self: None
	ArchiveValueRecord_Float_swigregister = _npstat.ArchiveValueRecord_Float_swigregister
	ArchiveValueRecord_Float_swigregister(ArchiveValueRecord_Float)


	def NPValueRecord_Float(object: 'float const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< float >":
	return _npstat.NPValueRecord_Float(object, name, category)
	NPValueRecord_Float = _npstat.NPValueRecord_Float
	class Ref_Float(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_Float, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_Float, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_Float(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'float *') -> "void":
	return _npstat.Ref_Float_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "float *":
	return _npstat.Ref_Float_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "float":
	return _npstat.Ref_Float_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_Float
	__del__ = lambda self: None
	Ref_Float_swigregister = _npstat.Ref_Float_swigregister
	Ref_Float_swigregister(Ref_Float)

	class ArchiveValueRecord_Double(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_Double, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_Double, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'double const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_Double(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_Double
	__del__ = lambda self: None
	ArchiveValueRecord_Double_swigregister = _npstat.ArchiveValueRecord_Double_swigregister
	ArchiveValueRecord_Double_swigregister(ArchiveValueRecord_Double)


	def NPValueRecord_Double(object: 'double const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< double >":
	return _npstat.NPValueRecord_Double(object, name, category)
	NPValueRecord_Double = _npstat.NPValueRecord_Double
	class Ref_Double(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_Double, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_Double, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_Double(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'double *') -> "void":
	return _npstat.Ref_Double_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "double *":
	return _npstat.Ref_Double_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "double":
	return _npstat.Ref_Double_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_Double
	__del__ = lambda self: None
	Ref_Double_swigregister = _npstat.Ref_Double_swigregister
	Ref_Double_swigregister(Ref_Double)

	class ArchiveValueRecord_LDouble(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_LDouble, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_LDouble, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'long double const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_LDouble(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_LDouble
	__del__ = lambda self: None
	ArchiveValueRecord_LDouble_swigregister = _npstat.ArchiveValueRecord_LDouble_swigregister
	ArchiveValueRecord_LDouble_swigregister(ArchiveValueRecord_LDouble)


	def NPValueRecord_LDouble(object: 'long double const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< long double >":
	return _npstat.NPValueRecord_LDouble(object, name, category)
	NPValueRecord_LDouble = _npstat.NPValueRecord_LDouble
	class Ref_LDouble(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_LDouble, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_LDouble, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_LDouble(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'long double *') -> "void":
	return _npstat.Ref_LDouble_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "long double *":
	return _npstat.Ref_LDouble_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "long double":
	return _npstat.Ref_LDouble_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_LDouble
	__del__ = lambda self: None
	Ref_LDouble_swigregister = _npstat.Ref_LDouble_swigregister
	Ref_LDouble_swigregister(Ref_LDouble)

	class ArchiveValueRecord_CFloat(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_CFloat, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_CFloat, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'std::complex< float > const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_CFloat(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_CFloat
	__del__ = lambda self: None
	ArchiveValueRecord_CFloat_swigregister = _npstat.ArchiveValueRecord_CFloat_swigregister
	ArchiveValueRecord_CFloat_swigregister(ArchiveValueRecord_CFloat)


	def NPValueRecord_CFloat(object: 'std::complex< float > const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::complex< float > >":
	return _npstat.NPValueRecord_CFloat(object, name, category)
	NPValueRecord_CFloat = _npstat.NPValueRecord_CFloat
	class Ref_CFloat(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_CFloat, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_CFloat, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_CFloat(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'std::complex< float > *') -> "void":
	return _npstat.Ref_CFloat_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::complex< float > *":
	return _npstat.Ref_CFloat_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::complex< float >":
	return _npstat.Ref_CFloat_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_CFloat
	__del__ = lambda self: None
	Ref_CFloat_swigregister = _npstat.Ref_CFloat_swigregister
	Ref_CFloat_swigregister(Ref_CFloat)

	class ArchiveValueRecord_CDouble(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_CDouble, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_CDouble, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'std::complex< double > const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_CDouble(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_CDouble
	__del__ = lambda self: None
	ArchiveValueRecord_CDouble_swigregister = _npstat.ArchiveValueRecord_CDouble_swigregister
	ArchiveValueRecord_CDouble_swigregister(ArchiveValueRecord_CDouble)


	def NPValueRecord_CDouble(object: 'std::complex< double > const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::complex< double > >":
	return _npstat.NPValueRecord_CDouble(object, name, category)
	NPValueRecord_CDouble = _npstat.NPValueRecord_CDouble
	class Ref_CDouble(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_CDouble, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_CDouble, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_CDouble(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'std::complex< double > *') -> "void":
	return _npstat.Ref_CDouble_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::complex< double > *":
	return _npstat.Ref_CDouble_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::complex< double >":
	return _npstat.Ref_CDouble_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_CDouble
	__del__ = lambda self: None
	Ref_CDouble_swigregister = _npstat.Ref_CDouble_swigregister
	Ref_CDouble_swigregister(Ref_CDouble)

	class ArchiveValueRecord_CLDouble(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_CLDouble, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_CLDouble, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'std::complex< long double > const &', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_CLDouble(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_CLDouble
	__del__ = lambda self: None
	ArchiveValueRecord_CLDouble_swigregister = _npstat.ArchiveValueRecord_CLDouble_swigregister
	ArchiveValueRecord_CLDouble_swigregister(ArchiveValueRecord_CLDouble)


	def NPValueRecord_CLDouble(object: 'std::complex< long double > const &', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::complex< long double > >":
	return _npstat.NPValueRecord_CLDouble(object, name, category)
	NPValueRecord_CLDouble = _npstat.NPValueRecord_CLDouble
	class Ref_CLDouble(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_CLDouble, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_CLDouble, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_CLDouble(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'std::complex< long double > *') -> "void":
	return _npstat.Ref_CLDouble_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::complex< long double > *":
	return _npstat.Ref_CLDouble_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::complex< long double >":
	return _npstat.Ref_CLDouble_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_CLDouble
	__del__ = lambda self: None
	Ref_CLDouble_swigregister = _npstat.Ref_CLDouble_swigregister
	Ref_CLDouble_swigregister(Ref_CLDouble)

	class ArchiveValueRecord_String(AbsRecord):
	__swig_setmethods__ = {}
	for _s in [AbsRecord]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, ArchiveValueRecord_String, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsRecord]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, ArchiveValueRecord_String, name)
	__repr__ = _swig_repr

	def __init__(self, object: 'string', name: 'char const ', category: 'char const '):
	this = _npstat.new_ArchiveValueRecord_String(object, name, category)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_ArchiveValueRecord_String
	__del__ = lambda self: None
	ArchiveValueRecord_String_swigregister = _npstat.ArchiveValueRecord_String_swigregister
	ArchiveValueRecord_String_swigregister(ArchiveValueRecord_String)


	def NPValueRecord_String(object: 'string', name: 'char const ', category: 'char const ') -> "gs::ArchiveValueRecord< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >":
	return _npstat.NPValueRecord_String(object, name, category)
	NPValueRecord_String = _npstat.NPValueRecord_String
	class Ref_String(AbsReference):
	__swig_setmethods__ = {}
	for _s in [AbsReference]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, Ref_String, name, value)
	__swig_getmethods__ = {}
	for _s in [AbsReference]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, Ref_String, name)
	__repr__ = _swig_repr

	def __init__(self, *args):
	this = _npstat.new_Ref_String(*args)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this

	def restore(self, index: 'unsigned long', obj: 'string') -> "void":
	return _npstat.Ref_String_restore(self, index, obj)

	def retrieve(self, index: 'unsigned long') -> "std::basic_string< char,std::char_traits< char >,std::allocator< char > > *":
	return _npstat.Ref_String_retrieve(self, index)

	def getValue(self, index: 'unsigned long') -> "std::basic_string< char,std::char_traits< char >,std::allocator< char > >":
	return _npstat.Ref_String_getValue(self, index)
	__swig_destroy__ = _npstat.delete_Ref_String
	__del__ = lambda self: None
	Ref_String_swigregister = _npstat.Ref_String_swigregister
	Ref_String_swigregister(Ref_String)

	class BinaryFileArchive(BinaryArchiveBase):
	__swig_setmethods__ = {}
	for _s in [BinaryArchiveBase]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, BinaryFileArchive, name, value)
	__swig_getmethods__ = {}
	for _s in [BinaryArchiveBase]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, BinaryFileArchive, name)
	__repr__ = _swig_repr

	def __init__(self, basename: 'char const ', mode: 'char const ', annotation: 'char const *'=None, dataFileBufferSize: 'unsigned int'=1048576, catalogFileBufferSize: 'unsigned int'=131072):
	this = _npstat.new_BinaryFileArchive(basename, mode, annotation, dataFileBufferSize, catalogFileBufferSize)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_BinaryFileArchive
	__del__ = lambda self: None

	def flush(self) -> "void":
	return _npstat.BinaryFileArchive_flush(self)
	BinaryFileArchive_swigregister = _npstat.BinaryFileArchive_swigregister
	BinaryFileArchive_swigregister(BinaryFileArchive)

	class MultiFileArchive(BinaryArchiveBase):
	__swig_setmethods__ = {}
	for _s in [BinaryArchiveBase]:
	__swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
	__setattr__ = lambda self, name, value: _swig_setattr(self, MultiFileArchive, name, value)
	__swig_getmethods__ = {}
	for _s in [BinaryArchiveBase]:
	__swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
	__getattr__ = lambda self, name: _swig_getattr(self, MultiFileArchive, name)
	__repr__ = _swig_repr

	def __init__(self, basename: 'char const ', mode: 'char const ', annotation: 'char const *'=None, typicalFileSizeInMB: 'unsigned int'=1000, dataFileBufferSize: 'unsigned int'=1048576, catalogFileBufferSize: 'unsigned int'=131072):
	this = _npstat.new_MultiFileArchive(basename, mode, annotation, typicalFileSizeInMB, dataFileBufferSize, catalogFileBufferSize)
	try:
	self.this.append(this)
	except __builtin__.Exception:
	self.this = this
	__swig_destroy__ = _npstat.delete_MultiFileArchive
	__del__ = lambda self: None

	def flush(self) -> "void":
	return _npstat.MultiFileArchive_flush(self)
	MultiFileArchive_swigregister = _npstat.MultiFileArchive_swigregister
	MultiFileArchive_swigregister(MultiFileArchive)

	# This file is compatible with both classic and new-style classes.



	Index: trunk/npstat/swig/stat/LocalPolyFilter1D.i
	===================================================================
	--- trunk/npstat/swig/stat/LocalPolyFilter1D.i (revision 618)
	+++ trunk/npstat/swig/stat/LocalPolyFilter1D.i (revision 619)
	@@ -1,34 +1,35 @@
	%include stddecls.i
	%include numpy.i
	%include nm/Matrix.i
	%include stat/AbsPolyFilter1D.i
	%include stat/AbsFilter1DBuilder.i
	%include stat/BoundaryHandling.i

	%{
	#include "npstat/stat/LocalPolyFilter1D.hh"
	%}

	%ignore npstat::LocalPolyFilter1D::doublyStochasticFilter;
	%ignore npstat::LocalPolyFilter1D::eigenGroomedFilter;
	%ignore npstat::LocalPolyFilter1D::filter;
	%ignore npstat::LocalPolyFilter1D::convolve;

	%rename(doublyStochasticFilter) npstat::LocalPolyFilter1D::doublyStochasticFilter_2;
	%rename(eigenGroomedFilter) npstat::LocalPolyFilter1D::eigenGroomedFilter_2;
	%rename(filter) npstat::LocalPolyFilter1D::filter_2;
	%rename(convolve) npstat::LocalPolyFilter1D::convolve_2;

	%ignore npstat::symbetaLOrPEFilter1D;
	+%newobject npstat::symbetaLOrPEFilter1D_2;
	%rename(symbetaLOrPEFilter1D) npstat::symbetaLOrPEFilter1D_2;

	%apply (double* IN_ARRAY1, int DIM1) {
	(const double* in, unsigned dataLen)
	};
	%apply (double* IN_ARRAY1, int DIM1) {
	(double* out, unsigned outLen)
	};

	%include "npstat/stat/LocalPolyFilter1D.hh"

	%clear (const double* in, unsigned dataLen), (double* out, unsigned outLen);
	Index: trunk/npstat/swig/stat/AbsMarginalSmootherBase.i
	===================================================================
	--- trunk/npstat/swig/stat/AbsMarginalSmootherBase.i (revision 618)
	+++ trunk/npstat/swig/stat/AbsMarginalSmootherBase.i (revision 619)
	@@ -1,22 +1,27 @@
	%include stddecls.i

	%include geners/AbsArchive.i
	%include stat/HistoND.i

	%{
	#include "npstat/stat/AbsMarginalSmootherBase.hh"
	%}

	%ignore npstat::AbsMarginalSmootherBase::smooth;
	%ignore npstat::AbsMarginalSmootherBase::weightedSmooth;

	+%newobject npstat::AbsMarginalSmootherBase::smooth2;
	+%newobject npstat::AbsMarginalSmootherBase::weightedSmooth2;
	+%newobject npstat::AbsMarginalSmootherBase::smoothArch;
	+%newobject npstat::AbsMarginalSmootherBase::weightedSmoothArch;
	+
	%include "npstat/stat/AbsMarginalSmootherBase.hh"

	namespace npstat {
	%extend AbsMarginalSmootherBase {
	%template(smooth) smooth2<std::vector<double> >;
	%template(weightedSmooth) weightedSmooth2<std::vector<std::pair<double,double> > >;
	%template(smoothArch) smoothArch<std::vector<double> >;
	%template(weightedSmoothArch) weightedSmoothArch<std::vector<std::pair<double,double> > >;
	}
	}
	Index: trunk/npstat/swig/npstat_wrap.cc
	===================================================================
	--- trunk/npstat/swig/npstat_wrap.cc (revision 618)
	+++ trunk/npstat/swig/npstat_wrap.cc (revision 619)
	@@ -839985,145612 +839985,145612 @@
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	PyObject arg2 = (PyObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	swig::SwigPyIterator *result = 0 ;

	arg2 = &obj0;
	if (!PyArg_ParseTuple(args,(char *)"O:DualAxisVector_iterator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_iterator" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	result = (swig::SwigPyIterator *)std_vector_Sl_npstat_DualAxis_Sg__iterator(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___nonzero__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:DualAxisVector___nonzero__",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector___nonzero__" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	result = (bool)std_vector_Sl_npstat_DualAxis_Sg____nonzero__((std::vector< npstat::DualAxis > const *)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___bool__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:DualAxisVector___bool__",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector___bool__" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	result = (bool)std_vector_Sl_npstat_DualAxis_Sg____bool__((std::vector< npstat::DualAxis > const *)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___len__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::DualAxis >::size_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:DualAxisVector___len__",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector___len__" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	result = std_vector_Sl_npstat_DualAxis_Sg____len__((std::vector< npstat::DualAxis > const *)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___getslice__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis >::difference_type arg2 ;
	std::vector< npstat::DualAxis >::difference_type arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DualAxisVector___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector___getslice__" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DualAxisVector___getslice__" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::DualAxis >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DualAxisVector___getslice__" "', argument " "3"" of type '" "std::vector< npstat::DualAxis >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::DualAxis >::difference_type >(val3);
	{
	try {
	try {
	result = (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > *)std_vector_Sl_npstat_DualAxis_Sg____getslice__(arg1,arg2,arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___setslice____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis >::difference_type arg2 ;
	std::vector< npstat::DualAxis >::difference_type arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DualAxisVector___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector___setslice__" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DualAxisVector___setslice__" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::DualAxis >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DualAxisVector___setslice__" "', argument " "3"" of type '" "std::vector< npstat::DualAxis >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::DualAxis >::difference_type >(val3);
	{
	try {
	try {
	std_vector_Sl_npstat_DualAxis_Sg____setslice____SWIG_0(arg1,arg2,arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___setslice____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis >::difference_type arg2 ;
	std::vector< npstat::DualAxis >::difference_type arg3 ;
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	int res4 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:DualAxisVector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector___setslice__" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DualAxisVector___setslice__" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::DualAxis >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DualAxisVector___setslice__" "', argument " "3"" of type '" "std::vector< npstat::DualAxis >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::DualAxis >::difference_type >(val3);
	{
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > ptr = (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > )0;
	res4 = swig::asptr(obj3, &ptr);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DualAxisVector___setslice__" "', argument " "4"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DualAxisVector___setslice__" "', argument " "4"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	arg4 = ptr;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_DualAxis_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &)*arg4);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (SWIG_IsNewObj(res4)) delete arg4;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res4)) delete arg4;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___setslice__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DualAxisVector___setslice____SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[3], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DualAxisVector___setslice____SWIG_1(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DualAxisVector___setslice__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::DualAxis >::__setslice__(std::vector< npstat::DualAxis >::difference_type,std::vector< npstat::DualAxis >::difference_type)\n"
	" std::vector< npstat::DualAxis >::__setslice__(std::vector< npstat::DualAxis >::difference_type,std::vector< npstat::DualAxis >::difference_type,std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___delslice__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis >::difference_type arg2 ;
	std::vector< npstat::DualAxis >::difference_type arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DualAxisVector___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector___delslice__" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DualAxisVector___delslice__" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::DualAxis >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DualAxisVector___delslice__" "', argument " "3"" of type '" "std::vector< npstat::DualAxis >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::DualAxis >::difference_type >(val3);
	{
	try {
	try {
	std_vector_Sl_npstat_DualAxis_Sg____delslice__(arg1,arg2,arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___delitem____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis >::difference_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DualAxisVector___delitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector___delitem__" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DualAxisVector___delitem__" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::DualAxis >::difference_type >(val2);
	{
	try {
	try {
	std_vector_Sl_npstat_DualAxis_Sg____delitem____SWIG_0(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___getitem____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DualAxisVector___getitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector___getitem__" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DualAxisVector___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	try {
	try {
	result = (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > *)std_vector_Sl_npstat_DualAxis_Sg____getitem____SWIG_0(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___setitem____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res3 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DualAxisVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector___setitem__" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DualAxisVector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > ptr = (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > )0;
	res3 = swig::asptr(obj2, &ptr);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DualAxisVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DualAxisVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	arg3 = ptr;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_DualAxis_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &)*arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (SWIG_IsNewObj(res3)) delete arg3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res3)) delete arg3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___setitem____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DualAxisVector___setitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector___setitem__" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DualAxisVector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_DualAxis_Sg____setitem____SWIG_1(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___delitem____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DualAxisVector___delitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector___delitem__" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DualAxisVector___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_DualAxis_Sg____delitem____SWIG_1(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___delitem__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	return _wrap_DualAxisVector___delitem____SWIG_1(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DualAxisVector___delitem____SWIG_0(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DualAxisVector___delitem__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::DualAxis >::__delitem__(std::vector< npstat::DualAxis >::difference_type)\n"
	" std::vector< npstat::DualAxis >::__delitem__(PySliceObject *)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___getitem____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis >::difference_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::DualAxis >::value_type *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DualAxisVector___getitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector___getitem__" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DualAxisVector___getitem__" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::DualAxis >::difference_type >(val2);
	{
	try {
	try {
	result = (std::vector< npstat::DualAxis >::value_type ) &std_vector_Sl_npstat_DualAxis_Sg____getitem____SWIG_1((std::vector< npstat::DualAxis > const )arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DualAxis, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___getitem__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	return _wrap_DualAxisVector___getitem____SWIG_0(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DualAxisVector___getitem____SWIG_1(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DualAxisVector___getitem__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::DualAxis >::__getitem__(PySliceObject *)\n"
	" std::vector< npstat::DualAxis >::__getitem__(std::vector< npstat::DualAxis >::difference_type) const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___setitem____SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis >::difference_type arg2 ;
	std::vector< npstat::DualAxis >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DualAxisVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector___setitem__" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DualAxisVector___setitem__" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::DualAxis >::difference_type >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DualAxisVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::DualAxis >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DualAxisVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::DualAxis >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::DualAxis >::value_type * >(argp3);
	{
	try {
	try {
	std_vector_Sl_npstat_DualAxis_Sg____setitem____SWIG_2(arg1,arg2,(npstat::DualAxis const &)*arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector___setitem__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	return _wrap_DualAxisVector___setitem____SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	int res = swig::asptr(argv[2], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DualAxisVector___setitem____SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DualAxisVector___setitem____SWIG_2(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DualAxisVector___setitem__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::DualAxis >::__setitem__(PySliceObject *,std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &)\n"
	" std::vector< npstat::DualAxis >::__setitem__(PySliceObject *)\n"
	" std::vector< npstat::DualAxis >::__setitem__(std::vector< npstat::DualAxis >::difference_type,std::vector< npstat::DualAxis >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_pop(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::DualAxis >::value_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:DualAxisVector_pop",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_pop" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	try {
	result = std_vector_Sl_npstat_DualAxis_Sg__pop(arg1);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new std::vector< npstat::DualAxis >::value_type(static_cast< const std::vector< npstat::DualAxis >::value_type& >(result))), SWIGTYPE_p_npstat__DualAxis, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_append(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis >::value_type *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DualAxisVector_append",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_append" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DualAxisVector_append" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::value_type const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DualAxisVector_append" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::value_type const &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::DualAxis >::value_type * >(argp2);
	{
	try {
	std_vector_Sl_npstat_DualAxis_Sg__append(arg1,(npstat::DualAxis const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DualAxisVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_DualAxisVector")) SWIG_fail;
	{
	try {
	result = (std::vector< npstat::DualAxis > *)new std::vector< npstat::DualAxis >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DualAxisVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > *arg1 = 0 ;
	int res1 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_DualAxisVector",&obj0)) SWIG_fail;
	{
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > ptr = (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DualAxisVector" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DualAxisVector" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > const &""'");
	}
	arg1 = ptr;
	}
	{
	try {
	result = (std::vector< npstat::DualAxis > )new std::vector< npstat::DualAxis >((std::vector< npstat::DualAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_empty(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:DualAxisVector_empty",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_empty" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	result = (bool)((std::vector< npstat::DualAxis > const *)arg1)->empty();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_size(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::DualAxis >::size_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:DualAxisVector_size",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_size" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	result = ((std::vector< npstat::DualAxis > const *)arg1)->size();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_swap(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DualAxisVector_swap",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_swap" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DualAxisVector_swap" "', argument " "2"" of type '" "std::vector< npstat::DualAxis > &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DualAxisVector_swap" "', argument " "2"" of type '" "std::vector< npstat::DualAxis > &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp2);
	{
	try {
	(arg1)->swap(*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_begin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::DualAxis >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:DualAxisVector_begin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_begin" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	result = (arg1)->begin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::DualAxis >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_end(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::DualAxis >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:DualAxisVector_end",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_end" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	result = (arg1)->end();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::DualAxis >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_rbegin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::DualAxis >::reverse_iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:DualAxisVector_rbegin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_rbegin" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	result = (arg1)->rbegin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::DualAxis >::reverse_iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_rend(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::DualAxis >::reverse_iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:DualAxisVector_rend",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_rend" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	result = (arg1)->rend();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::DualAxis >::reverse_iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DualAxisVector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_clear" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_get_allocator(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< std::allocator< npstat::DualAxis > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:DualAxisVector_get_allocator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_get_allocator" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	result = ((std::vector< npstat::DualAxis > const *)arg1)->get_allocator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new std::vector< npstat::DualAxis >::allocator_type(static_cast< const std::vector< npstat::DualAxis >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_npstat__DualAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DualAxisVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis >::size_type arg1 ;
	size_t val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_DualAxisVector",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_size_t(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DualAxisVector" "', argument " "1"" of type '" "std::vector< npstat::DualAxis >::size_type""'");
	}
	arg1 = static_cast< std::vector< npstat::DualAxis >::size_type >(val1);
	{
	try {
	result = (std::vector< npstat::DualAxis > *)new std::vector< npstat::DualAxis >(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_pop_back(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DualAxisVector_pop_back",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_pop_back" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	(arg1)->pop_back();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_resize__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis >::size_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DualAxisVector_resize",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_resize" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DualAxisVector_resize" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::DualAxis >::size_type >(val2);
	{
	try {
	(arg1)->resize(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_erase__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis >::iterator arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::DualAxis >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DualAxisVector_erase",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_erase" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DualAxisVector_erase" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::DualAxis >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::DualAxis >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DualAxisVector_erase" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::iterator""'");
	}
	}
	{
	try {
	result = std_vector_Sl_npstat_DualAxis_Sg__erase__SWIG_0(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::DualAxis >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_erase__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis >::iterator arg2 ;
	std::vector< npstat::DualAxis >::iterator arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	swig::SwigPyIterator *iter3 = 0 ;
	int res3 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	std::vector< npstat::DualAxis >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DualAxisVector_erase",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_erase" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DualAxisVector_erase" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::DualAxis >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::DualAxis >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DualAxisVector_erase" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::iterator""'");
	}
	}
	res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res3) \|\| !iter3) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DualAxisVector_erase" "', argument " "3"" of type '" "std::vector< npstat::DualAxis >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::DualAxis >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::DualAxis >::iterator > >(iter3);
	if (iter_t) {
	arg3 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DualAxisVector_erase" "', argument " "3"" of type '" "std::vector< npstat::DualAxis >::iterator""'");
	}
	}
	{
	try {
	result = std_vector_Sl_npstat_DualAxis_Sg__erase__SWIG_1(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::DualAxis >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_erase(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::DualAxis >::iterator > *>(iter) != 0));
	if (_v) {
	return _wrap_DualAxisVector_erase__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::DualAxis >::iterator > *>(iter) != 0));
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::DualAxis >::iterator > *>(iter) != 0));
	if (_v) {
	return _wrap_DualAxisVector_erase__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DualAxisVector_erase'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::DualAxis >::erase(std::vector< npstat::DualAxis >::iterator)\n"
	" std::vector< npstat::DualAxis >::erase(std::vector< npstat::DualAxis >::iterator,std::vector< npstat::DualAxis >::iterator)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_new_DualAxisVector__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis >::size_type arg1 ;
	std::vector< npstat::DualAxis >::value_type *arg2 = 0 ;
	size_t val1 ;
	int ecode1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_DualAxisVector",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_size_t(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DualAxisVector" "', argument " "1"" of type '" "std::vector< npstat::DualAxis >::size_type""'");
	}
	arg1 = static_cast< std::vector< npstat::DualAxis >::size_type >(val1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DualAxisVector" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::value_type const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DualAxisVector" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::value_type const &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::DualAxis >::value_type * >(argp2);
	{
	try {
	result = (std::vector< npstat::DualAxis > )new std::vector< npstat::DualAxis >(arg1,(std::vector< npstat::DualAxis >::value_type const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DualAxisVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 0) {
	return _wrap_new_DualAxisVector__SWIG_0(self, args);
	}
	if (argc == 1) {
	int _v;
	{
	int res = SWIG_AsVal_size_t(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DualAxisVector__SWIG_2(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DualAxisVector__SWIG_1(self, args);
	}
	}
	if (argc == 2) {
	int _v;
	{
	int res = SWIG_AsVal_size_t(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DualAxisVector__SWIG_3(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DualAxisVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::DualAxis >::vector()\n"
	" std::vector< npstat::DualAxis >::vector(std::vector< npstat::DualAxis > const &)\n"
	" std::vector< npstat::DualAxis >::vector(std::vector< npstat::DualAxis >::size_type)\n"
	" std::vector< npstat::DualAxis >::vector(std::vector< npstat::DualAxis >::size_type,std::vector< npstat::DualAxis >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_push_back(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis >::value_type *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DualAxisVector_push_back",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_push_back" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DualAxisVector_push_back" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::value_type const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DualAxisVector_push_back" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::value_type const &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::DualAxis >::value_type * >(argp2);
	{
	try {
	(arg1)->push_back((std::vector< npstat::DualAxis >::value_type const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_front(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::DualAxis >::value_type *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DualAxisVector_front",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_front" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	result = (std::vector< npstat::DualAxis >::value_type ) &((std::vector< npstat::DualAxis > const )arg1)->front();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DualAxis, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_back(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::DualAxis >::value_type *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DualAxisVector_back",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_back" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	result = (std::vector< npstat::DualAxis >::value_type ) &((std::vector< npstat::DualAxis > const )arg1)->back();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DualAxis, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_assign(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis >::size_type arg2 ;
	std::vector< npstat::DualAxis >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DualAxisVector_assign",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_assign" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DualAxisVector_assign" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::DualAxis >::size_type >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DualAxisVector_assign" "', argument " "3"" of type '" "std::vector< npstat::DualAxis >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DualAxisVector_assign" "', argument " "3"" of type '" "std::vector< npstat::DualAxis >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::DualAxis >::value_type * >(argp3);
	{
	try {
	(arg1)->assign(arg2,(std::vector< npstat::DualAxis >::value_type const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_resize__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis >::size_type arg2 ;
	std::vector< npstat::DualAxis >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DualAxisVector_resize",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_resize" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DualAxisVector_resize" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::DualAxis >::size_type >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DualAxisVector_resize" "', argument " "3"" of type '" "std::vector< npstat::DualAxis >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DualAxisVector_resize" "', argument " "3"" of type '" "std::vector< npstat::DualAxis >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::DualAxis >::value_type * >(argp3);
	{
	try {
	(arg1)->resize(arg2,(std::vector< npstat::DualAxis >::value_type const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_resize(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_size_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DualAxisVector_resize__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_size_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DualAxisVector_resize__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DualAxisVector_resize'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::DualAxis >::resize(std::vector< npstat::DualAxis >::size_type)\n"
	" std::vector< npstat::DualAxis >::resize(std::vector< npstat::DualAxis >::size_type,std::vector< npstat::DualAxis >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_insert__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis >::iterator arg2 ;
	std::vector< npstat::DualAxis >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	std::vector< npstat::DualAxis >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DualAxisVector_insert",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_insert" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DualAxisVector_insert" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::DualAxis >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::DualAxis >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DualAxisVector_insert" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::iterator""'");
	}
	}
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DualAxisVector_insert" "', argument " "3"" of type '" "std::vector< npstat::DualAxis >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DualAxisVector_insert" "', argument " "3"" of type '" "std::vector< npstat::DualAxis >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::DualAxis >::value_type * >(argp3);
	{
	try {
	result = std_vector_Sl_npstat_DualAxis_Sg__insert__SWIG_0(arg1,arg2,(npstat::DualAxis const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::DualAxis >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_insert__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis >::iterator arg2 ;
	std::vector< npstat::DualAxis >::size_type arg3 ;
	std::vector< npstat::DualAxis >::value_type *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	size_t val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:DualAxisVector_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_insert" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DualAxisVector_insert" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::DualAxis >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::DualAxis >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DualAxisVector_insert" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::iterator""'");
	}
	}
	ecode3 = SWIG_AsVal_size_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DualAxisVector_insert" "', argument " "3"" of type '" "std::vector< npstat::DualAxis >::size_type""'");
	}
	arg3 = static_cast< std::vector< npstat::DualAxis >::size_type >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DualAxisVector_insert" "', argument " "4"" of type '" "std::vector< npstat::DualAxis >::value_type const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DualAxisVector_insert" "', argument " "4"" of type '" "std::vector< npstat::DualAxis >::value_type const &""'");
	}
	arg4 = reinterpret_cast< std::vector< npstat::DualAxis >::value_type * >(argp4);
	{
	try {
	std_vector_Sl_npstat_DualAxis_Sg__insert__SWIG_1(arg1,arg2,arg3,(npstat::DualAxis const &)*arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_insert(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::DualAxis >::iterator > *>(iter) != 0));
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DualAxisVector_insert__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::DualAxis >::iterator > *>(iter) != 0));
	if (_v) {
	{
	int res = SWIG_AsVal_size_t(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DualAxisVector_insert__SWIG_1(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DualAxisVector_insert'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::DualAxis >::insert(std::vector< npstat::DualAxis >::iterator,std::vector< npstat::DualAxis >::value_type const &)\n"
	" std::vector< npstat::DualAxis >::insert(std::vector< npstat::DualAxis >::iterator,std::vector< npstat::DualAxis >::size_type,std::vector< npstat::DualAxis >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_reserve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	std::vector< npstat::DualAxis >::size_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DualAxisVector_reserve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_reserve" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DualAxisVector_reserve" "', argument " "2"" of type '" "std::vector< npstat::DualAxis >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::DualAxis >::size_type >(val2);
	{
	try {
	(arg1)->reserve(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DualAxisVector_capacity(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::DualAxis >::size_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:DualAxisVector_capacity",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DualAxisVector_capacity" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	result = ((std::vector< npstat::DualAxis > const *)arg1)->capacity();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DualAxisVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis > arg1 = (std::vector< npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DualAxisVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DualAxisVector" "', argument " "1"" of type '" "std::vector< npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::DualAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DualAxisVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_npstat__DualAxis_std__allocatorT_npstat__DualAxis_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DoubleLinInterpolatedTableND__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DoubleLinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > ptr = (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< double,npstat::UniformAxis >((std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleLinInterpolatedTableND__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_DoubleLinInterpolatedTableND",&obj0,&obj1)) SWIG_fail;
	{
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > ptr = (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< double,npstat::UniformAxis >((std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleLinInterpolatedTableND__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	char arg4 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	int res4 ;
	char *buf4 = 0 ;
	int alloc4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_DoubleLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "4"" of type '" "char const *""'");
	}
	arg4 = reinterpret_cast< char * >(buf4);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(char const *)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return resultobj;
	fail:
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleLinInterpolatedTableND__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DoubleLinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleLinInterpolatedTableND__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	char arg7 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	int res7 ;
	char *buf7 = 0 ;
	int alloc7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_DoubleLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "7"" of type '" "char const *""'");
	}
	arg7 = reinterpret_cast< char * >(buf7);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(char const )arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return resultobj;
	fail:
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleLinInterpolatedTableND__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_DoubleLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)*arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleLinInterpolatedTableND__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	char arg10 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	int res10 ;
	char *buf10 = 0 ;
	int alloc10 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_DoubleLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "10"" of type '" "char const *""'");
	}
	arg10 = reinterpret_cast< char * >(buf10);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(char const *)arg10);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return resultobj;
	fail:
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleLinInterpolatedTableND__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_DoubleLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleLinInterpolatedTableND__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::UniformAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	char arg13 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	int res13 ;
	char *buf13 = 0 ;
	int alloc13 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:new_DoubleLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::UniformAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_AsCharPtrAndSize(obj12, &buf13, NULL, &alloc13);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "13"" of type '" "char const *""'");
	}
	arg13 = reinterpret_cast< char * >(buf13);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(npstat::UniformAxis const &)arg10,arg11,arg12,(char const )arg13);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return resultobj;
	fail:
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleLinInterpolatedTableND__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::UniformAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_DoubleLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::UniformAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(npstat::UniformAxis const &)*arg10,arg11,arg12);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleLinInterpolatedTableND__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::UniformAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::UniformAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	char arg16 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	int res16 ;
	char *buf16 = 0 ;
	int alloc16 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	PyObject * obj15 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:new_DoubleLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::UniformAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "13"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "13"" of type '" "npstat::UniformAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::UniformAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	res16 = SWIG_AsCharPtrAndSize(obj15, &buf16, NULL, &alloc16);
	if (!SWIG_IsOK(res16)) {
	SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "16"" of type '" "char const *""'");
	}
	arg16 = reinterpret_cast< char * >(buf16);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(npstat::UniformAxis const &)arg10,arg11,arg12,(npstat::UniformAxis const &)arg13,arg14,arg15,(char const *)arg16);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return resultobj;
	fail:
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleLinInterpolatedTableND__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::UniformAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::UniformAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:new_DoubleLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::UniformAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "13"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "13"" of type '" "npstat::UniformAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::UniformAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_DoubleLinInterpolatedTableND" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(npstat::UniformAxis const &)arg10,arg11,arg12,(npstat::UniformAxis const &)arg13,arg14,arg15);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleLinInterpolatedTableND(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[17] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 16) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleLinInterpolatedTableND__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleLinInterpolatedTableND__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleLinInterpolatedTableND__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleLinInterpolatedTableND__SWIG_2(self, args);
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleLinInterpolatedTableND__SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[6], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleLinInterpolatedTableND__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 9) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleLinInterpolatedTableND__SWIG_7(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 10) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleLinInterpolatedTableND__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 12) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleLinInterpolatedTableND__SWIG_9(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 13) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[12], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleLinInterpolatedTableND__SWIG_8(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 15) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleLinInterpolatedTableND__SWIG_11(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 16) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[15], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleLinInterpolatedTableND__SWIG_10(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DoubleLinInterpolatedTableND'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::LinInterpolatedTableND(std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::LinInterpolatedTableND(std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND___call____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyArrayObject *array2 = NULL ;
	int is_new_object2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleLinInterpolatedTableND___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	{
	npy_intp size[1] = {
	-1
	};
	array2 = obj_to_array_contiguous_allow_conversion(obj1,
	NPY_DOUBLE,
	&is_new_object2);
	if (!array2 \|\| !require_dimensions(array2, 1) \|\|
	!require_size(array2, size, 1)) SWIG_fail;
	arg2 = (double*) array_data(array2);
	arg3 = (int) array_size(array2,0);
	}
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND___call____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	double *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleLinInterpolatedTableND___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const )arg1)->operator ()((double const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND___call____SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleLinInterpolatedTableND___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const )arg1)->operator ()((double const &)arg2,(double const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND___call____SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:DoubleLinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND___call____SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	double *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	double temp5 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:DoubleLinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "5"" of type '" "double""'");
	}
	temp5 = static_cast< double >(val5);
	arg5 = &temp5;
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4,(double const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND___call____SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	double *arg5 = 0 ;
	double *arg6 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	double temp5 ;
	double val5 ;
	int ecode5 = 0 ;
	double temp6 ;
	double val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:DoubleLinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "5"" of type '" "double""'");
	}
	temp5 = static_cast< double >(val5);
	arg5 = &temp5;
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DoubleLinInterpolatedTableND___call__" "', argument " "6"" of type '" "double""'");
	}
	temp6 = static_cast< double >(val6);
	arg6 = &temp6;
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4,(double const &)arg5,(double const &)arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND___call__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[7] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 6) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DoubleLinInterpolatedTableND___call____SWIG_1(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = is_array(argv[1]) \|\| PySequence_Check(argv[1]);
	}
	if (_v) {
	if (argc <= 2) {
	return _wrap_DoubleLinInterpolatedTableND___call____SWIG_0(self, args);
	}
	return _wrap_DoubleLinInterpolatedTableND___call____SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DoubleLinInterpolatedTableND___call____SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DoubleLinInterpolatedTableND___call____SWIG_3(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DoubleLinInterpolatedTableND___call____SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DoubleLinInterpolatedTableND___call____SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleLinInterpolatedTableND___call__'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::operator ()(double const *,unsigned int) const\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::operator ()(double const &) const\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::operator ()(double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::operator ()(double const &,double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::operator ()(double const &,double const &,double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::operator ()(double const &,double const &,double const &,double const &,double const &) const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_dim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleLinInterpolatedTableND_dim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND_dim" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *)arg1)->dim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_axes(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleLinInterpolatedTableND_axes",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND_axes" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > ) &((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const )arg1)->axes();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_axis(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::UniformAxis *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleLinInterpolatedTableND_axis",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND_axis" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleLinInterpolatedTableND_axis" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (npstat::UniformAxis ) &((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const )arg1)->axis(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__UniformAxis, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_length(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleLinInterpolatedTableND_length",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND_length" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *)arg1)->length();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_leftInterpolationLinear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleLinInterpolatedTableND_leftInterpolationLinear",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND_leftInterpolationLinear" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleLinInterpolatedTableND_leftInterpolationLinear" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *)arg1)->leftInterpolationLinear(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_rightInterpolationLinear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleLinInterpolatedTableND_rightInterpolationLinear",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND_rightInterpolationLinear" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleLinInterpolatedTableND_rightInterpolationLinear" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *)arg1)->rightInterpolationLinear(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_interpolationType(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleLinInterpolatedTableND_interpolationType",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND_interpolationType" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = ((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *)arg1)->interpolationType();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >(static_cast< const std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >& >(result))), SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_functionLabel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::string *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleLinInterpolatedTableND_functionLabel",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND_functionLabel" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (std::string ) &((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const )arg1)->functionLabel();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleLinInterpolatedTableND_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND_table" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > ) &((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleLinInterpolatedTableND_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND_table" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleLinInterpolatedTableND_table__SWIG_1(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleLinInterpolatedTableND_table__SWIG_0(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleLinInterpolatedTableND_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::table() const\n"
	" npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::table()\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_getCoords(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	unsigned long arg2 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:DoubleLinInterpolatedTableND_getCoords",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND_getCoords" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleLinInterpolatedTableND_getCoords" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleLinInterpolatedTableND_getCoords" "', argument " "3"" of type '" "double *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleLinInterpolatedTableND_getCoords" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *)arg1)->getCoords(arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_isUniformlyBinned(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleLinInterpolatedTableND_isUniformlyBinned",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND_isUniformlyBinned" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *)arg1)->isUniformlyBinned();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_isWithinLimits(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyArrayObject *array2 = NULL ;
	int is_new_object2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleLinInterpolatedTableND_isWithinLimits",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND_isWithinLimits" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	{
	npy_intp size[1] = {
	-1
	};
	array2 = obj_to_array_contiguous_allow_conversion(obj1,
	NPY_DOUBLE,
	&is_new_object2);
	if (!array2 \|\| !require_dimensions(array2, 1) \|\|
	!require_size(array2, size, 1)) SWIG_fail;
	arg2 = (double*) array_data(array2);
	arg3 = (int) array_size(array2,0);
	}
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const )arg1)->isWithinLimits((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_setFunctionLabel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	char arg2 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleLinInterpolatedTableND_setFunctionLabel",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND_setFunctionLabel" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleLinInterpolatedTableND_setFunctionLabel" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	{
	try {
	(arg1)->setFunctionLabel((char const *)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND___eq__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleLinInterpolatedTableND___eq__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND___eq__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleLinInterpolatedTableND___eq__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleLinInterpolatedTableND___eq__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const &""'");
	}
	arg2 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const )arg1)->operator ==((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND___ne__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleLinInterpolatedTableND___ne__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND___ne__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleLinInterpolatedTableND___ne__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleLinInterpolatedTableND___ne__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const &""'");
	}
	arg2 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const )arg1)->operator !=((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleLinInterpolatedTableND_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND_classId" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = ((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleLinInterpolatedTableND_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND_write" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleLinInterpolatedTableND_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleLinInterpolatedTableND_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":DoubleLinInterpolatedTableND_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":DoubleLinInterpolatedTableND_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleLinInterpolatedTableND_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleLinInterpolatedTableND_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleLinInterpolatedTableND_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleLinInterpolatedTableND_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleLinInterpolatedTableND_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleLinInterpolatedTableND_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > )npstat::LinInterpolatedTableND< double,npstat::UniformAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DoubleLinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleLinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleLinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DoubleNULinInterpolatedTableND__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DoubleNULinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > ptr = (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > )new npstat::LinInterpolatedTableND< double,npstat::GridAxis >((std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNULinInterpolatedTableND__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_DoubleNULinInterpolatedTableND",&obj0,&obj1)) SWIG_fail;
	{
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > ptr = (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > )new npstat::LinInterpolatedTableND< double,npstat::GridAxis >((std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNULinInterpolatedTableND__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	char arg4 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	int res4 ;
	char *buf4 = 0 ;
	int alloc4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_DoubleNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "4"" of type '" "char const *""'");
	}
	arg4 = reinterpret_cast< char * >(buf4);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > )new npstat::LinInterpolatedTableND< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(char const *)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return resultobj;
	fail:
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNULinInterpolatedTableND__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DoubleNULinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > )new npstat::LinInterpolatedTableND< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNULinInterpolatedTableND__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	char arg7 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	int res7 ;
	char *buf7 = 0 ;
	int alloc7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_DoubleNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "7"" of type '" "char const *""'");
	}
	arg7 = reinterpret_cast< char * >(buf7);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > )new npstat::LinInterpolatedTableND< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(char const )arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return resultobj;
	fail:
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNULinInterpolatedTableND__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_DoubleNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > )new npstat::LinInterpolatedTableND< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)*arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNULinInterpolatedTableND__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	char arg10 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	int res10 ;
	char *buf10 = 0 ;
	int alloc10 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_DoubleNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "10"" of type '" "char const *""'");
	}
	arg10 = reinterpret_cast< char * >(buf10);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > )new npstat::LinInterpolatedTableND< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(char const *)arg10);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return resultobj;
	fail:
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNULinInterpolatedTableND__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_DoubleNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > )new npstat::LinInterpolatedTableND< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNULinInterpolatedTableND__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::GridAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	char arg13 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	int res13 ;
	char *buf13 = 0 ;
	int alloc13 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:new_DoubleNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::GridAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_AsCharPtrAndSize(obj12, &buf13, NULL, &alloc13);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "13"" of type '" "char const *""'");
	}
	arg13 = reinterpret_cast< char * >(buf13);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > )new npstat::LinInterpolatedTableND< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(npstat::GridAxis const &)arg10,arg11,arg12,(char const )arg13);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return resultobj;
	fail:
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNULinInterpolatedTableND__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::GridAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_DoubleNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::GridAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > )new npstat::LinInterpolatedTableND< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(npstat::GridAxis const &)*arg10,arg11,arg12);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNULinInterpolatedTableND__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::GridAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::GridAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	char arg16 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	int res16 ;
	char *buf16 = 0 ;
	int alloc16 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	PyObject * obj15 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:new_DoubleNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::GridAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "13"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "13"" of type '" "npstat::GridAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::GridAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	res16 = SWIG_AsCharPtrAndSize(obj15, &buf16, NULL, &alloc16);
	if (!SWIG_IsOK(res16)) {
	SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "16"" of type '" "char const *""'");
	}
	arg16 = reinterpret_cast< char * >(buf16);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > )new npstat::LinInterpolatedTableND< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(npstat::GridAxis const &)arg10,arg11,arg12,(npstat::GridAxis const &)arg13,arg14,arg15,(char const *)arg16);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return resultobj;
	fail:
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNULinInterpolatedTableND__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::GridAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::GridAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:new_DoubleNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::GridAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "13"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "13"" of type '" "npstat::GridAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::GridAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_DoubleNULinInterpolatedTableND" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > )new npstat::LinInterpolatedTableND< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(npstat::GridAxis const &)arg10,arg11,arg12,(npstat::GridAxis const &)arg13,arg14,arg15);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNULinInterpolatedTableND(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[17] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 16) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleNULinInterpolatedTableND__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleNULinInterpolatedTableND__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleNULinInterpolatedTableND__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleNULinInterpolatedTableND__SWIG_2(self, args);
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleNULinInterpolatedTableND__SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[6], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleNULinInterpolatedTableND__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 9) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleNULinInterpolatedTableND__SWIG_7(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 10) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleNULinInterpolatedTableND__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 12) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleNULinInterpolatedTableND__SWIG_9(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 13) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[12], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleNULinInterpolatedTableND__SWIG_8(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 15) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleNULinInterpolatedTableND__SWIG_11(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 16) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[15], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleNULinInterpolatedTableND__SWIG_10(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DoubleNULinInterpolatedTableND'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::LinInterpolatedTableND(std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::LinInterpolatedTableND(std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND___call____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyArrayObject *array2 = NULL ;
	int is_new_object2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNULinInterpolatedTableND___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	{
	npy_intp size[1] = {
	-1
	};
	array2 = obj_to_array_contiguous_allow_conversion(obj1,
	NPY_DOUBLE,
	&is_new_object2);
	if (!array2 \|\| !require_dimensions(array2, 1) \|\|
	!require_size(array2, size, 1)) SWIG_fail;
	arg2 = (double*) array_data(array2);
	arg3 = (int) array_size(array2,0);
	}
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND___call____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	double *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNULinInterpolatedTableND___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const )arg1)->operator ()((double const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND___call____SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleNULinInterpolatedTableND___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const )arg1)->operator ()((double const &)arg2,(double const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND___call____SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:DoubleNULinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND___call____SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	double *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	double temp5 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:DoubleNULinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "5"" of type '" "double""'");
	}
	temp5 = static_cast< double >(val5);
	arg5 = &temp5;
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4,(double const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND___call____SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	double *arg5 = 0 ;
	double *arg6 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	double temp5 ;
	double val5 ;
	int ecode5 = 0 ;
	double temp6 ;
	double val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:DoubleNULinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "5"" of type '" "double""'");
	}
	temp5 = static_cast< double >(val5);
	arg5 = &temp5;
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DoubleNULinInterpolatedTableND___call__" "', argument " "6"" of type '" "double""'");
	}
	temp6 = static_cast< double >(val6);
	arg6 = &temp6;
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4,(double const &)arg5,(double const &)arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND___call__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[7] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 6) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DoubleNULinInterpolatedTableND___call____SWIG_1(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = is_array(argv[1]) \|\| PySequence_Check(argv[1]);
	}
	if (_v) {
	if (argc <= 2) {
	return _wrap_DoubleNULinInterpolatedTableND___call____SWIG_0(self, args);
	}
	return _wrap_DoubleNULinInterpolatedTableND___call____SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DoubleNULinInterpolatedTableND___call____SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DoubleNULinInterpolatedTableND___call____SWIG_3(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DoubleNULinInterpolatedTableND___call____SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DoubleNULinInterpolatedTableND___call____SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleNULinInterpolatedTableND___call__'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::operator ()(double const *,unsigned int) const\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::operator ()(double const &) const\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::operator ()(double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::operator ()(double const &,double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::operator ()(double const &,double const &,double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::operator ()(double const &,double const &,double const &,double const &,double const &) const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_dim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNULinInterpolatedTableND_dim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND_dim" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *)arg1)->dim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_axes(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNULinInterpolatedTableND_axes",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND_axes" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > ) &((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const )arg1)->axes();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_axis(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::GridAxis *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNULinInterpolatedTableND_axis",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND_axis" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleNULinInterpolatedTableND_axis" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (npstat::GridAxis ) &((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const )arg1)->axis(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__GridAxis, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_length(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNULinInterpolatedTableND_length",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND_length" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *)arg1)->length();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_leftInterpolationLinear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNULinInterpolatedTableND_leftInterpolationLinear",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND_leftInterpolationLinear" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleNULinInterpolatedTableND_leftInterpolationLinear" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *)arg1)->leftInterpolationLinear(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_rightInterpolationLinear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNULinInterpolatedTableND_rightInterpolationLinear",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND_rightInterpolationLinear" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleNULinInterpolatedTableND_rightInterpolationLinear" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *)arg1)->rightInterpolationLinear(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_interpolationType(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNULinInterpolatedTableND_interpolationType",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND_interpolationType" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	{
	try {
	result = ((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *)arg1)->interpolationType();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >(static_cast< const std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >& >(result))), SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_functionLabel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::string *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNULinInterpolatedTableND_functionLabel",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND_functionLabel" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (std::string ) &((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const )arg1)->functionLabel();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNULinInterpolatedTableND_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND_table" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > ) &((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNULinInterpolatedTableND_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND_table" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleNULinInterpolatedTableND_table__SWIG_1(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleNULinInterpolatedTableND_table__SWIG_0(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleNULinInterpolatedTableND_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::table() const\n"
	" npstat::LinInterpolatedTableND< double,npstat::GridAxis >::table()\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_getCoords(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	unsigned long arg2 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:DoubleNULinInterpolatedTableND_getCoords",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND_getCoords" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleNULinInterpolatedTableND_getCoords" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleNULinInterpolatedTableND_getCoords" "', argument " "3"" of type '" "double *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleNULinInterpolatedTableND_getCoords" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *)arg1)->getCoords(arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_isUniformlyBinned(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNULinInterpolatedTableND_isUniformlyBinned",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND_isUniformlyBinned" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *)arg1)->isUniformlyBinned();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_isWithinLimits(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyArrayObject *array2 = NULL ;
	int is_new_object2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNULinInterpolatedTableND_isWithinLimits",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND_isWithinLimits" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	{
	npy_intp size[1] = {
	-1
	};
	array2 = obj_to_array_contiguous_allow_conversion(obj1,
	NPY_DOUBLE,
	&is_new_object2);
	if (!array2 \|\| !require_dimensions(array2, 1) \|\|
	!require_size(array2, size, 1)) SWIG_fail;
	arg2 = (double*) array_data(array2);
	arg3 = (int) array_size(array2,0);
	}
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const )arg1)->isWithinLimits((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_setFunctionLabel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	char arg2 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNULinInterpolatedTableND_setFunctionLabel",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND_setFunctionLabel" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleNULinInterpolatedTableND_setFunctionLabel" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	{
	try {
	(arg1)->setFunctionLabel((char const *)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND___eq__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNULinInterpolatedTableND___eq__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND___eq__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleNULinInterpolatedTableND___eq__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleNULinInterpolatedTableND___eq__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const &""'");
	}
	arg2 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const )arg1)->operator ==((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND___ne__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNULinInterpolatedTableND___ne__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND___ne__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleNULinInterpolatedTableND___ne__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleNULinInterpolatedTableND___ne__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const &""'");
	}
	arg2 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const )arg1)->operator !=((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNULinInterpolatedTableND_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND_classId" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	{
	try {
	result = ((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNULinInterpolatedTableND_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND_write" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleNULinInterpolatedTableND_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleNULinInterpolatedTableND_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":DoubleNULinInterpolatedTableND_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::LinInterpolatedTableND< double,npstat::GridAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":DoubleNULinInterpolatedTableND_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::LinInterpolatedTableND< double,npstat::GridAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNULinInterpolatedTableND_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNULinInterpolatedTableND_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNULinInterpolatedTableND_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleNULinInterpolatedTableND_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleNULinInterpolatedTableND_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleNULinInterpolatedTableND_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > )npstat::LinInterpolatedTableND< double,npstat::GridAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DoubleNULinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleNULinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleNULinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DoubleDALinInterpolatedTableND__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DoubleDALinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > ptr = (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > )new npstat::LinInterpolatedTableND< double,npstat::DualAxis >((std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleDALinInterpolatedTableND__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_DoubleDALinInterpolatedTableND",&obj0,&obj1)) SWIG_fail;
	{
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > ptr = (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > )new npstat::LinInterpolatedTableND< double,npstat::DualAxis >((std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleDALinInterpolatedTableND__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	char arg4 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	int res4 ;
	char *buf4 = 0 ;
	int alloc4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_DoubleDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "4"" of type '" "char const *""'");
	}
	arg4 = reinterpret_cast< char * >(buf4);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > )new npstat::LinInterpolatedTableND< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(char const *)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return resultobj;
	fail:
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleDALinInterpolatedTableND__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DoubleDALinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > )new npstat::LinInterpolatedTableND< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleDALinInterpolatedTableND__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	char arg7 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	int res7 ;
	char *buf7 = 0 ;
	int alloc7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_DoubleDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "7"" of type '" "char const *""'");
	}
	arg7 = reinterpret_cast< char * >(buf7);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > )new npstat::LinInterpolatedTableND< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(char const )arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return resultobj;
	fail:
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleDALinInterpolatedTableND__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_DoubleDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > )new npstat::LinInterpolatedTableND< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)*arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleDALinInterpolatedTableND__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	char arg10 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	int res10 ;
	char *buf10 = 0 ;
	int alloc10 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_DoubleDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "10"" of type '" "char const *""'");
	}
	arg10 = reinterpret_cast< char * >(buf10);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > )new npstat::LinInterpolatedTableND< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(char const *)arg10);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return resultobj;
	fail:
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleDALinInterpolatedTableND__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_DoubleDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > )new npstat::LinInterpolatedTableND< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleDALinInterpolatedTableND__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::DualAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	char arg13 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	int res13 ;
	char *buf13 = 0 ;
	int alloc13 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:new_DoubleDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::DualAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_AsCharPtrAndSize(obj12, &buf13, NULL, &alloc13);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "13"" of type '" "char const *""'");
	}
	arg13 = reinterpret_cast< char * >(buf13);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > )new npstat::LinInterpolatedTableND< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(npstat::DualAxis const &)arg10,arg11,arg12,(char const )arg13);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return resultobj;
	fail:
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleDALinInterpolatedTableND__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::DualAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_DoubleDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::DualAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > )new npstat::LinInterpolatedTableND< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(npstat::DualAxis const &)*arg10,arg11,arg12);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleDALinInterpolatedTableND__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::DualAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::DualAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	char arg16 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	int res16 ;
	char *buf16 = 0 ;
	int alloc16 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	PyObject * obj15 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:new_DoubleDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::DualAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "13"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "13"" of type '" "npstat::DualAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::DualAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	res16 = SWIG_AsCharPtrAndSize(obj15, &buf16, NULL, &alloc16);
	if (!SWIG_IsOK(res16)) {
	SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "16"" of type '" "char const *""'");
	}
	arg16 = reinterpret_cast< char * >(buf16);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > )new npstat::LinInterpolatedTableND< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(npstat::DualAxis const &)arg10,arg11,arg12,(npstat::DualAxis const &)arg13,arg14,arg15,(char const *)arg16);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return resultobj;
	fail:
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleDALinInterpolatedTableND__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::DualAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::DualAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:new_DoubleDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::DualAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "13"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "13"" of type '" "npstat::DualAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::DualAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_DoubleDALinInterpolatedTableND" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > )new npstat::LinInterpolatedTableND< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(npstat::DualAxis const &)arg10,arg11,arg12,(npstat::DualAxis const &)arg13,arg14,arg15);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleDALinInterpolatedTableND(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[17] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 16) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleDALinInterpolatedTableND__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleDALinInterpolatedTableND__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleDALinInterpolatedTableND__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleDALinInterpolatedTableND__SWIG_2(self, args);
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleDALinInterpolatedTableND__SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[6], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleDALinInterpolatedTableND__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 9) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleDALinInterpolatedTableND__SWIG_7(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 10) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleDALinInterpolatedTableND__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 12) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleDALinInterpolatedTableND__SWIG_9(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 13) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[12], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleDALinInterpolatedTableND__SWIG_8(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 15) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleDALinInterpolatedTableND__SWIG_11(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 16) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[15], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleDALinInterpolatedTableND__SWIG_10(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DoubleDALinInterpolatedTableND'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::LinInterpolatedTableND(std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::LinInterpolatedTableND(std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND___call____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyArrayObject *array2 = NULL ;
	int is_new_object2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleDALinInterpolatedTableND___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	{
	npy_intp size[1] = {
	-1
	};
	array2 = obj_to_array_contiguous_allow_conversion(obj1,
	NPY_DOUBLE,
	&is_new_object2);
	if (!array2 \|\| !require_dimensions(array2, 1) \|\|
	!require_size(array2, size, 1)) SWIG_fail;
	arg2 = (double*) array_data(array2);
	arg3 = (int) array_size(array2,0);
	}
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND___call____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	double *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleDALinInterpolatedTableND___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const )arg1)->operator ()((double const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND___call____SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleDALinInterpolatedTableND___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const )arg1)->operator ()((double const &)arg2,(double const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND___call____SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:DoubleDALinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND___call____SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	double *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	double temp5 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:DoubleDALinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "5"" of type '" "double""'");
	}
	temp5 = static_cast< double >(val5);
	arg5 = &temp5;
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4,(double const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND___call____SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	double *arg5 = 0 ;
	double *arg6 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	double temp5 ;
	double val5 ;
	int ecode5 = 0 ;
	double temp6 ;
	double val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:DoubleDALinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "5"" of type '" "double""'");
	}
	temp5 = static_cast< double >(val5);
	arg5 = &temp5;
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DoubleDALinInterpolatedTableND___call__" "', argument " "6"" of type '" "double""'");
	}
	temp6 = static_cast< double >(val6);
	arg6 = &temp6;
	{
	try {
	result = (double)((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4,(double const &)arg5,(double const &)arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND___call__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[7] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 6) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DoubleDALinInterpolatedTableND___call____SWIG_1(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = is_array(argv[1]) \|\| PySequence_Check(argv[1]);
	}
	if (_v) {
	if (argc <= 2) {
	return _wrap_DoubleDALinInterpolatedTableND___call____SWIG_0(self, args);
	}
	return _wrap_DoubleDALinInterpolatedTableND___call____SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DoubleDALinInterpolatedTableND___call____SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DoubleDALinInterpolatedTableND___call____SWIG_3(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DoubleDALinInterpolatedTableND___call____SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_DoubleDALinInterpolatedTableND___call____SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleDALinInterpolatedTableND___call__'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::operator ()(double const *,unsigned int) const\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::operator ()(double const &) const\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::operator ()(double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::operator ()(double const &,double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::operator ()(double const &,double const &,double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::operator ()(double const &,double const &,double const &,double const &,double const &) const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_dim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleDALinInterpolatedTableND_dim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND_dim" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *)arg1)->dim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_axes(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleDALinInterpolatedTableND_axes",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND_axes" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > ) &((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const )arg1)->axes();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_axis(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::DualAxis *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleDALinInterpolatedTableND_axis",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND_axis" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDALinInterpolatedTableND_axis" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (npstat::DualAxis ) &((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const )arg1)->axis(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DualAxis, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_length(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleDALinInterpolatedTableND_length",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND_length" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *)arg1)->length();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_leftInterpolationLinear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleDALinInterpolatedTableND_leftInterpolationLinear",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND_leftInterpolationLinear" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDALinInterpolatedTableND_leftInterpolationLinear" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *)arg1)->leftInterpolationLinear(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_rightInterpolationLinear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleDALinInterpolatedTableND_rightInterpolationLinear",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND_rightInterpolationLinear" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDALinInterpolatedTableND_rightInterpolationLinear" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *)arg1)->rightInterpolationLinear(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_interpolationType(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleDALinInterpolatedTableND_interpolationType",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND_interpolationType" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	{
	try {
	result = ((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *)arg1)->interpolationType();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >(static_cast< const std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >& >(result))), SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_functionLabel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::string *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleDALinInterpolatedTableND_functionLabel",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND_functionLabel" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (std::string ) &((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const )arg1)->functionLabel();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleDALinInterpolatedTableND_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND_table" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > ) &((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleDALinInterpolatedTableND_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND_table" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleDALinInterpolatedTableND_table__SWIG_1(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleDALinInterpolatedTableND_table__SWIG_0(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleDALinInterpolatedTableND_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::table() const\n"
	" npstat::LinInterpolatedTableND< double,npstat::DualAxis >::table()\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_getCoords(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	unsigned long arg2 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:DoubleDALinInterpolatedTableND_getCoords",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND_getCoords" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDALinInterpolatedTableND_getCoords" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleDALinInterpolatedTableND_getCoords" "', argument " "3"" of type '" "double *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleDALinInterpolatedTableND_getCoords" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *)arg1)->getCoords(arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_isUniformlyBinned(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleDALinInterpolatedTableND_isUniformlyBinned",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND_isUniformlyBinned" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *)arg1)->isUniformlyBinned();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_isWithinLimits(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyArrayObject *array2 = NULL ;
	int is_new_object2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleDALinInterpolatedTableND_isWithinLimits",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND_isWithinLimits" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	{
	npy_intp size[1] = {
	-1
	};
	array2 = obj_to_array_contiguous_allow_conversion(obj1,
	NPY_DOUBLE,
	&is_new_object2);
	if (!array2 \|\| !require_dimensions(array2, 1) \|\|
	!require_size(array2, size, 1)) SWIG_fail;
	arg2 = (double*) array_data(array2);
	arg3 = (int) array_size(array2,0);
	}
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const )arg1)->isWithinLimits((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_setFunctionLabel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	char arg2 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleDALinInterpolatedTableND_setFunctionLabel",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND_setFunctionLabel" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleDALinInterpolatedTableND_setFunctionLabel" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	{
	try {
	(arg1)->setFunctionLabel((char const *)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND___eq__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleDALinInterpolatedTableND___eq__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND___eq__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleDALinInterpolatedTableND___eq__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleDALinInterpolatedTableND___eq__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const &""'");
	}
	arg2 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const )arg1)->operator ==((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND___ne__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleDALinInterpolatedTableND___ne__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND___ne__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleDALinInterpolatedTableND___ne__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleDALinInterpolatedTableND___ne__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const &""'");
	}
	arg2 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const )arg1)->operator !=((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleDALinInterpolatedTableND_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND_classId" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	{
	try {
	result = ((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleDALinInterpolatedTableND_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND_write" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleDALinInterpolatedTableND_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleDALinInterpolatedTableND_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":DoubleDALinInterpolatedTableND_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::LinInterpolatedTableND< double,npstat::DualAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":DoubleDALinInterpolatedTableND_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::LinInterpolatedTableND< double,npstat::DualAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDALinInterpolatedTableND_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleDALinInterpolatedTableND_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDALinInterpolatedTableND_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleDALinInterpolatedTableND_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleDALinInterpolatedTableND_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleDALinInterpolatedTableND_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > )npstat::LinInterpolatedTableND< double,npstat::DualAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DoubleDALinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleDALinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleDALinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_FloatLinInterpolatedTableND__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_FloatLinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > ptr = (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< float,npstat::UniformAxis >((std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatLinInterpolatedTableND__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_FloatLinInterpolatedTableND",&obj0,&obj1)) SWIG_fail;
	{
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > ptr = (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< float,npstat::UniformAxis >((std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatLinInterpolatedTableND__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	char arg4 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	int res4 ;
	char *buf4 = 0 ;
	int alloc4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_FloatLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "4"" of type '" "char const *""'");
	}
	arg4 = reinterpret_cast< char * >(buf4);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(char const *)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return resultobj;
	fail:
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatLinInterpolatedTableND__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_FloatLinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatLinInterpolatedTableND__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	char arg7 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	int res7 ;
	char *buf7 = 0 ;
	int alloc7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_FloatLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "7"" of type '" "char const *""'");
	}
	arg7 = reinterpret_cast< char * >(buf7);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(char const )arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return resultobj;
	fail:
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatLinInterpolatedTableND__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_FloatLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)*arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatLinInterpolatedTableND__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	char arg10 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	int res10 ;
	char *buf10 = 0 ;
	int alloc10 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_FloatLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "10"" of type '" "char const *""'");
	}
	arg10 = reinterpret_cast< char * >(buf10);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(char const *)arg10);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return resultobj;
	fail:
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatLinInterpolatedTableND__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_FloatLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatLinInterpolatedTableND__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::UniformAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	char arg13 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	int res13 ;
	char *buf13 = 0 ;
	int alloc13 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:new_FloatLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::UniformAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_AsCharPtrAndSize(obj12, &buf13, NULL, &alloc13);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "13"" of type '" "char const *""'");
	}
	arg13 = reinterpret_cast< char * >(buf13);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(npstat::UniformAxis const &)arg10,arg11,arg12,(char const )arg13);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return resultobj;
	fail:
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatLinInterpolatedTableND__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::UniformAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_FloatLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::UniformAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(npstat::UniformAxis const &)*arg10,arg11,arg12);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatLinInterpolatedTableND__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::UniformAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::UniformAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	char arg16 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	int res16 ;
	char *buf16 = 0 ;
	int alloc16 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	PyObject * obj15 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:new_FloatLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::UniformAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "13"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "13"" of type '" "npstat::UniformAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::UniformAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	res16 = SWIG_AsCharPtrAndSize(obj15, &buf16, NULL, &alloc16);
	if (!SWIG_IsOK(res16)) {
	SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "16"" of type '" "char const *""'");
	}
	arg16 = reinterpret_cast< char * >(buf16);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(npstat::UniformAxis const &)arg10,arg11,arg12,(npstat::UniformAxis const &)arg13,arg14,arg15,(char const *)arg16);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return resultobj;
	fail:
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatLinInterpolatedTableND__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::UniformAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::UniformAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:new_FloatLinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::UniformAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "13"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatLinInterpolatedTableND" "', argument " "13"" of type '" "npstat::UniformAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::UniformAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FloatLinInterpolatedTableND" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > )new npstat::LinInterpolatedTableND< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(npstat::UniformAxis const &)arg10,arg11,arg12,(npstat::UniformAxis const &)arg13,arg14,arg15);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatLinInterpolatedTableND(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[17] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 16) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatLinInterpolatedTableND__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatLinInterpolatedTableND__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatLinInterpolatedTableND__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatLinInterpolatedTableND__SWIG_2(self, args);
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatLinInterpolatedTableND__SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[6], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatLinInterpolatedTableND__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 9) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatLinInterpolatedTableND__SWIG_7(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 10) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatLinInterpolatedTableND__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 12) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatLinInterpolatedTableND__SWIG_9(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 13) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[12], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatLinInterpolatedTableND__SWIG_8(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 15) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatLinInterpolatedTableND__SWIG_11(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 16) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[15], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatLinInterpolatedTableND__SWIG_10(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FloatLinInterpolatedTableND'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::LinInterpolatedTableND(std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::LinInterpolatedTableND(std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::LinInterpolatedTableND(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND___call____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyArrayObject *array2 = NULL ;
	int is_new_object2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatLinInterpolatedTableND___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	{
	npy_intp size[1] = {
	-1
	};
	array2 = obj_to_array_contiguous_allow_conversion(obj1,
	NPY_DOUBLE,
	&is_new_object2);
	if (!array2 \|\| !require_dimensions(array2, 1) \|\|
	!require_size(array2, size, 1)) SWIG_fail;
	arg2 = (double*) array_data(array2);
	arg3 = (int) array_size(array2,0);
	}
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND___call____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	double *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatLinInterpolatedTableND___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const )arg1)->operator ()((double const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND___call____SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:FloatLinInterpolatedTableND___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const )arg1)->operator ()((double const &)arg2,(double const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND___call____SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:FloatLinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND___call____SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	double *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	double temp5 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:FloatLinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "5"" of type '" "double""'");
	}
	temp5 = static_cast< double >(val5);
	arg5 = &temp5;
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4,(double const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND___call____SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	double *arg5 = 0 ;
	double *arg6 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	double temp5 ;
	double val5 ;
	int ecode5 = 0 ;
	double temp6 ;
	double val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:FloatLinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "5"" of type '" "double""'");
	}
	temp5 = static_cast< double >(val5);
	arg5 = &temp5;
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FloatLinInterpolatedTableND___call__" "', argument " "6"" of type '" "double""'");
	}
	temp6 = static_cast< double >(val6);
	arg6 = &temp6;
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4,(double const &)arg5,(double const &)arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND___call__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[7] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 6) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_FloatLinInterpolatedTableND___call____SWIG_1(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = is_array(argv[1]) \|\| PySequence_Check(argv[1]);
	}
	if (_v) {
	if (argc <= 2) {
	return _wrap_FloatLinInterpolatedTableND___call____SWIG_0(self, args);
	}
	return _wrap_FloatLinInterpolatedTableND___call____SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_FloatLinInterpolatedTableND___call____SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_FloatLinInterpolatedTableND___call____SWIG_3(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_FloatLinInterpolatedTableND___call____SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_FloatLinInterpolatedTableND___call____SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatLinInterpolatedTableND___call__'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::operator ()(double const *,unsigned int) const\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::operator ()(double const &) const\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::operator ()(double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::operator ()(double const &,double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::operator ()(double const &,double const &,double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::operator ()(double const &,double const &,double const &,double const &,double const &) const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_dim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatLinInterpolatedTableND_dim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND_dim" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *)arg1)->dim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_axes(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatLinInterpolatedTableND_axes",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND_axes" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > ) &((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const )arg1)->axes();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_axis(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::UniformAxis *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatLinInterpolatedTableND_axis",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND_axis" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatLinInterpolatedTableND_axis" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (npstat::UniformAxis ) &((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const )arg1)->axis(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__UniformAxis, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_length(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatLinInterpolatedTableND_length",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND_length" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *)arg1)->length();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_leftInterpolationLinear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatLinInterpolatedTableND_leftInterpolationLinear",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND_leftInterpolationLinear" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatLinInterpolatedTableND_leftInterpolationLinear" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *)arg1)->leftInterpolationLinear(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_rightInterpolationLinear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatLinInterpolatedTableND_rightInterpolationLinear",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND_rightInterpolationLinear" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatLinInterpolatedTableND_rightInterpolationLinear" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *)arg1)->rightInterpolationLinear(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_interpolationType(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatLinInterpolatedTableND_interpolationType",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND_interpolationType" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = ((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *)arg1)->interpolationType();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >(static_cast< const std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >& >(result))), SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_functionLabel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::string *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatLinInterpolatedTableND_functionLabel",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND_functionLabel" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (std::string ) &((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const )arg1)->functionLabel();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatLinInterpolatedTableND_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND_table" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > ) &((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatLinInterpolatedTableND_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND_table" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatLinInterpolatedTableND_table__SWIG_1(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatLinInterpolatedTableND_table__SWIG_0(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatLinInterpolatedTableND_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::table() const\n"
	" npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::table()\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_getCoords(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	unsigned long arg2 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:FloatLinInterpolatedTableND_getCoords",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND_getCoords" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatLinInterpolatedTableND_getCoords" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FloatLinInterpolatedTableND_getCoords" "', argument " "3"" of type '" "double *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatLinInterpolatedTableND_getCoords" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *)arg1)->getCoords(arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_isUniformlyBinned(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatLinInterpolatedTableND_isUniformlyBinned",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND_isUniformlyBinned" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *)arg1)->isUniformlyBinned();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_isWithinLimits(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyArrayObject *array2 = NULL ;
	int is_new_object2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatLinInterpolatedTableND_isWithinLimits",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND_isWithinLimits" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	{
	npy_intp size[1] = {
	-1
	};
	array2 = obj_to_array_contiguous_allow_conversion(obj1,
	NPY_DOUBLE,
	&is_new_object2);
	if (!array2 \|\| !require_dimensions(array2, 1) \|\|
	!require_size(array2, size, 1)) SWIG_fail;
	arg2 = (double*) array_data(array2);
	arg3 = (int) array_size(array2,0);
	}
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const )arg1)->isWithinLimits((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_setFunctionLabel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	char arg2 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatLinInterpolatedTableND_setFunctionLabel",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND_setFunctionLabel" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatLinInterpolatedTableND_setFunctionLabel" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	{
	try {
	(arg1)->setFunctionLabel((char const *)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND___eq__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatLinInterpolatedTableND___eq__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND___eq__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatLinInterpolatedTableND___eq__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatLinInterpolatedTableND___eq__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const &""'");
	}
	arg2 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const )arg1)->operator ==((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND___ne__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatLinInterpolatedTableND___ne__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND___ne__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatLinInterpolatedTableND___ne__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatLinInterpolatedTableND___ne__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const &""'");
	}
	arg2 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const )arg1)->operator !=((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatLinInterpolatedTableND_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND_classId" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = ((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatLinInterpolatedTableND_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND_write" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatLinInterpolatedTableND_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatLinInterpolatedTableND_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":FloatLinInterpolatedTableND_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":FloatLinInterpolatedTableND_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatLinInterpolatedTableND_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatLinInterpolatedTableND_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatLinInterpolatedTableND_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatLinInterpolatedTableND_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatLinInterpolatedTableND_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatLinInterpolatedTableND_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > )npstat::LinInterpolatedTableND< float,npstat::UniformAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_FloatLinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatLinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatLinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_FloatNULinInterpolatedTableND__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_FloatNULinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > ptr = (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > )new npstat::LinInterpolatedTableND< float,npstat::GridAxis >((std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNULinInterpolatedTableND__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_FloatNULinInterpolatedTableND",&obj0,&obj1)) SWIG_fail;
	{
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > ptr = (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > )new npstat::LinInterpolatedTableND< float,npstat::GridAxis >((std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNULinInterpolatedTableND__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	char arg4 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	int res4 ;
	char *buf4 = 0 ;
	int alloc4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_FloatNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "4"" of type '" "char const *""'");
	}
	arg4 = reinterpret_cast< char * >(buf4);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > )new npstat::LinInterpolatedTableND< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(char const *)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return resultobj;
	fail:
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNULinInterpolatedTableND__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_FloatNULinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > )new npstat::LinInterpolatedTableND< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNULinInterpolatedTableND__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	char arg7 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	int res7 ;
	char *buf7 = 0 ;
	int alloc7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_FloatNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "7"" of type '" "char const *""'");
	}
	arg7 = reinterpret_cast< char * >(buf7);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > )new npstat::LinInterpolatedTableND< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(char const )arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return resultobj;
	fail:
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNULinInterpolatedTableND__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_FloatNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > )new npstat::LinInterpolatedTableND< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)*arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNULinInterpolatedTableND__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	char arg10 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	int res10 ;
	char *buf10 = 0 ;
	int alloc10 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_FloatNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "10"" of type '" "char const *""'");
	}
	arg10 = reinterpret_cast< char * >(buf10);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > )new npstat::LinInterpolatedTableND< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(char const *)arg10);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return resultobj;
	fail:
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNULinInterpolatedTableND__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_FloatNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > )new npstat::LinInterpolatedTableND< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNULinInterpolatedTableND__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::GridAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	char arg13 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	int res13 ;
	char *buf13 = 0 ;
	int alloc13 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:new_FloatNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::GridAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_AsCharPtrAndSize(obj12, &buf13, NULL, &alloc13);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "13"" of type '" "char const *""'");
	}
	arg13 = reinterpret_cast< char * >(buf13);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > )new npstat::LinInterpolatedTableND< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(npstat::GridAxis const &)arg10,arg11,arg12,(char const )arg13);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return resultobj;
	fail:
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNULinInterpolatedTableND__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::GridAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_FloatNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::GridAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > )new npstat::LinInterpolatedTableND< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(npstat::GridAxis const &)*arg10,arg11,arg12);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNULinInterpolatedTableND__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::GridAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::GridAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	char arg16 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	int res16 ;
	char *buf16 = 0 ;
	int alloc16 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	PyObject * obj15 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:new_FloatNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::GridAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "13"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "13"" of type '" "npstat::GridAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::GridAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	res16 = SWIG_AsCharPtrAndSize(obj15, &buf16, NULL, &alloc16);
	if (!SWIG_IsOK(res16)) {
	SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "16"" of type '" "char const *""'");
	}
	arg16 = reinterpret_cast< char * >(buf16);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > )new npstat::LinInterpolatedTableND< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(npstat::GridAxis const &)arg10,arg11,arg12,(npstat::GridAxis const &)arg13,arg14,arg15,(char const *)arg16);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return resultobj;
	fail:
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNULinInterpolatedTableND__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::GridAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::GridAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:new_FloatNULinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::GridAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "13"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "13"" of type '" "npstat::GridAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::GridAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FloatNULinInterpolatedTableND" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > )new npstat::LinInterpolatedTableND< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(npstat::GridAxis const &)arg10,arg11,arg12,(npstat::GridAxis const &)arg13,arg14,arg15);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNULinInterpolatedTableND(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[17] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 16) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatNULinInterpolatedTableND__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatNULinInterpolatedTableND__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatNULinInterpolatedTableND__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatNULinInterpolatedTableND__SWIG_2(self, args);
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatNULinInterpolatedTableND__SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[6], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatNULinInterpolatedTableND__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 9) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatNULinInterpolatedTableND__SWIG_7(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 10) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatNULinInterpolatedTableND__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 12) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatNULinInterpolatedTableND__SWIG_9(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 13) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[12], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatNULinInterpolatedTableND__SWIG_8(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 15) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatNULinInterpolatedTableND__SWIG_11(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 16) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[15], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatNULinInterpolatedTableND__SWIG_10(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FloatNULinInterpolatedTableND'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::LinInterpolatedTableND(std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::LinInterpolatedTableND(std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::LinInterpolatedTableND(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND___call____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyArrayObject *array2 = NULL ;
	int is_new_object2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNULinInterpolatedTableND___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	{
	npy_intp size[1] = {
	-1
	};
	array2 = obj_to_array_contiguous_allow_conversion(obj1,
	NPY_DOUBLE,
	&is_new_object2);
	if (!array2 \|\| !require_dimensions(array2, 1) \|\|
	!require_size(array2, size, 1)) SWIG_fail;
	arg2 = (double*) array_data(array2);
	arg3 = (int) array_size(array2,0);
	}
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND___call____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	double *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNULinInterpolatedTableND___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const )arg1)->operator ()((double const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND___call____SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:FloatNULinInterpolatedTableND___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const )arg1)->operator ()((double const &)arg2,(double const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND___call____SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:FloatNULinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND___call____SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	double *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	double temp5 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:FloatNULinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "5"" of type '" "double""'");
	}
	temp5 = static_cast< double >(val5);
	arg5 = &temp5;
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4,(double const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND___call____SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	double *arg5 = 0 ;
	double *arg6 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	double temp5 ;
	double val5 ;
	int ecode5 = 0 ;
	double temp6 ;
	double val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:FloatNULinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "5"" of type '" "double""'");
	}
	temp5 = static_cast< double >(val5);
	arg5 = &temp5;
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FloatNULinInterpolatedTableND___call__" "', argument " "6"" of type '" "double""'");
	}
	temp6 = static_cast< double >(val6);
	arg6 = &temp6;
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4,(double const &)arg5,(double const &)arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND___call__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[7] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 6) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_FloatNULinInterpolatedTableND___call____SWIG_1(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = is_array(argv[1]) \|\| PySequence_Check(argv[1]);
	}
	if (_v) {
	if (argc <= 2) {
	return _wrap_FloatNULinInterpolatedTableND___call____SWIG_0(self, args);
	}
	return _wrap_FloatNULinInterpolatedTableND___call____SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_FloatNULinInterpolatedTableND___call____SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_FloatNULinInterpolatedTableND___call____SWIG_3(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_FloatNULinInterpolatedTableND___call____SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_FloatNULinInterpolatedTableND___call____SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatNULinInterpolatedTableND___call__'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::operator ()(double const *,unsigned int) const\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::operator ()(double const &) const\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::operator ()(double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::operator ()(double const &,double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::operator ()(double const &,double const &,double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::operator ()(double const &,double const &,double const &,double const &,double const &) const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_dim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNULinInterpolatedTableND_dim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND_dim" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *)arg1)->dim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_axes(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNULinInterpolatedTableND_axes",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND_axes" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > ) &((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const )arg1)->axes();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_axis(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::GridAxis *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNULinInterpolatedTableND_axis",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND_axis" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatNULinInterpolatedTableND_axis" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (npstat::GridAxis ) &((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const )arg1)->axis(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__GridAxis, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_length(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNULinInterpolatedTableND_length",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND_length" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *)arg1)->length();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_leftInterpolationLinear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNULinInterpolatedTableND_leftInterpolationLinear",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND_leftInterpolationLinear" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatNULinInterpolatedTableND_leftInterpolationLinear" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *)arg1)->leftInterpolationLinear(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_rightInterpolationLinear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNULinInterpolatedTableND_rightInterpolationLinear",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND_rightInterpolationLinear" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatNULinInterpolatedTableND_rightInterpolationLinear" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *)arg1)->rightInterpolationLinear(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_interpolationType(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNULinInterpolatedTableND_interpolationType",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND_interpolationType" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	{
	try {
	result = ((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *)arg1)->interpolationType();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >(static_cast< const std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >& >(result))), SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_functionLabel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::string *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNULinInterpolatedTableND_functionLabel",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND_functionLabel" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (std::string ) &((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const )arg1)->functionLabel();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNULinInterpolatedTableND_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND_table" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > ) &((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNULinInterpolatedTableND_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND_table" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatNULinInterpolatedTableND_table__SWIG_1(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatNULinInterpolatedTableND_table__SWIG_0(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatNULinInterpolatedTableND_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::table() const\n"
	" npstat::LinInterpolatedTableND< float,npstat::GridAxis >::table()\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_getCoords(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	unsigned long arg2 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:FloatNULinInterpolatedTableND_getCoords",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND_getCoords" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatNULinInterpolatedTableND_getCoords" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FloatNULinInterpolatedTableND_getCoords" "', argument " "3"" of type '" "double *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatNULinInterpolatedTableND_getCoords" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *)arg1)->getCoords(arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_isUniformlyBinned(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNULinInterpolatedTableND_isUniformlyBinned",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND_isUniformlyBinned" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *)arg1)->isUniformlyBinned();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_isWithinLimits(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyArrayObject *array2 = NULL ;
	int is_new_object2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNULinInterpolatedTableND_isWithinLimits",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND_isWithinLimits" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	{
	npy_intp size[1] = {
	-1
	};
	array2 = obj_to_array_contiguous_allow_conversion(obj1,
	NPY_DOUBLE,
	&is_new_object2);
	if (!array2 \|\| !require_dimensions(array2, 1) \|\|
	!require_size(array2, size, 1)) SWIG_fail;
	arg2 = (double*) array_data(array2);
	arg3 = (int) array_size(array2,0);
	}
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const )arg1)->isWithinLimits((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_setFunctionLabel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	char arg2 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNULinInterpolatedTableND_setFunctionLabel",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND_setFunctionLabel" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatNULinInterpolatedTableND_setFunctionLabel" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	{
	try {
	(arg1)->setFunctionLabel((char const *)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND___eq__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNULinInterpolatedTableND___eq__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND___eq__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatNULinInterpolatedTableND___eq__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatNULinInterpolatedTableND___eq__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const &""'");
	}
	arg2 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const )arg1)->operator ==((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND___ne__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNULinInterpolatedTableND___ne__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND___ne__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatNULinInterpolatedTableND___ne__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatNULinInterpolatedTableND___ne__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const &""'");
	}
	arg2 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const )arg1)->operator !=((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNULinInterpolatedTableND_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND_classId" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	{
	try {
	result = ((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNULinInterpolatedTableND_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND_write" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatNULinInterpolatedTableND_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatNULinInterpolatedTableND_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":FloatNULinInterpolatedTableND_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::LinInterpolatedTableND< float,npstat::GridAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":FloatNULinInterpolatedTableND_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::LinInterpolatedTableND< float,npstat::GridAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNULinInterpolatedTableND_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNULinInterpolatedTableND_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNULinInterpolatedTableND_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatNULinInterpolatedTableND_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatNULinInterpolatedTableND_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatNULinInterpolatedTableND_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > )npstat::LinInterpolatedTableND< float,npstat::GridAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_FloatNULinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatNULinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatNULinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_FloatDALinInterpolatedTableND__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_FloatDALinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > ptr = (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > )new npstat::LinInterpolatedTableND< float,npstat::DualAxis >((std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatDALinInterpolatedTableND__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_FloatDALinInterpolatedTableND",&obj0,&obj1)) SWIG_fail;
	{
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > ptr = (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > )new npstat::LinInterpolatedTableND< float,npstat::DualAxis >((std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatDALinInterpolatedTableND__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	char arg4 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	int res4 ;
	char *buf4 = 0 ;
	int alloc4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_FloatDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "4"" of type '" "char const *""'");
	}
	arg4 = reinterpret_cast< char * >(buf4);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > )new npstat::LinInterpolatedTableND< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(char const *)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return resultobj;
	fail:
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatDALinInterpolatedTableND__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_FloatDALinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > )new npstat::LinInterpolatedTableND< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatDALinInterpolatedTableND__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	char arg7 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	int res7 ;
	char *buf7 = 0 ;
	int alloc7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_FloatDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "7"" of type '" "char const *""'");
	}
	arg7 = reinterpret_cast< char * >(buf7);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > )new npstat::LinInterpolatedTableND< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(char const )arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return resultobj;
	fail:
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatDALinInterpolatedTableND__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_FloatDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > )new npstat::LinInterpolatedTableND< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)*arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatDALinInterpolatedTableND__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	char arg10 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	int res10 ;
	char *buf10 = 0 ;
	int alloc10 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_FloatDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "10"" of type '" "char const *""'");
	}
	arg10 = reinterpret_cast< char * >(buf10);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > )new npstat::LinInterpolatedTableND< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(char const *)arg10);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return resultobj;
	fail:
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatDALinInterpolatedTableND__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_FloatDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > )new npstat::LinInterpolatedTableND< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatDALinInterpolatedTableND__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::DualAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	char arg13 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	int res13 ;
	char *buf13 = 0 ;
	int alloc13 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:new_FloatDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::DualAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_AsCharPtrAndSize(obj12, &buf13, NULL, &alloc13);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "13"" of type '" "char const *""'");
	}
	arg13 = reinterpret_cast< char * >(buf13);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > )new npstat::LinInterpolatedTableND< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(npstat::DualAxis const &)arg10,arg11,arg12,(char const )arg13);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return resultobj;
	fail:
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatDALinInterpolatedTableND__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::DualAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_FloatDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::DualAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > )new npstat::LinInterpolatedTableND< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(npstat::DualAxis const &)*arg10,arg11,arg12);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatDALinInterpolatedTableND__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::DualAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::DualAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	char arg16 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	int res16 ;
	char *buf16 = 0 ;
	int alloc16 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	PyObject * obj15 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:new_FloatDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::DualAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "13"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "13"" of type '" "npstat::DualAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::DualAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	res16 = SWIG_AsCharPtrAndSize(obj15, &buf16, NULL, &alloc16);
	if (!SWIG_IsOK(res16)) {
	SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "16"" of type '" "char const *""'");
	}
	arg16 = reinterpret_cast< char * >(buf16);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > )new npstat::LinInterpolatedTableND< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(npstat::DualAxis const &)arg10,arg11,arg12,(npstat::DualAxis const &)arg13,arg14,arg15,(char const *)arg16);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return resultobj;
	fail:
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatDALinInterpolatedTableND__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::DualAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::DualAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:new_FloatDALinInterpolatedTableND",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::DualAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "13"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "13"" of type '" "npstat::DualAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::DualAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FloatDALinInterpolatedTableND" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > )new npstat::LinInterpolatedTableND< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(npstat::DualAxis const &)arg10,arg11,arg12,(npstat::DualAxis const &)arg13,arg14,arg15);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatDALinInterpolatedTableND(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[17] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 16) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatDALinInterpolatedTableND__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatDALinInterpolatedTableND__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatDALinInterpolatedTableND__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatDALinInterpolatedTableND__SWIG_2(self, args);
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatDALinInterpolatedTableND__SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[6], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatDALinInterpolatedTableND__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 9) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatDALinInterpolatedTableND__SWIG_7(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 10) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatDALinInterpolatedTableND__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 12) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatDALinInterpolatedTableND__SWIG_9(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 13) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[12], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatDALinInterpolatedTableND__SWIG_8(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 15) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatDALinInterpolatedTableND__SWIG_11(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 16) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[15], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatDALinInterpolatedTableND__SWIG_10(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FloatDALinInterpolatedTableND'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::LinInterpolatedTableND(std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::LinInterpolatedTableND(std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool)\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::LinInterpolatedTableND(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND___call____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyArrayObject *array2 = NULL ;
	int is_new_object2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatDALinInterpolatedTableND___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	{
	npy_intp size[1] = {
	-1
	};
	array2 = obj_to_array_contiguous_allow_conversion(obj1,
	NPY_DOUBLE,
	&is_new_object2);
	if (!array2 \|\| !require_dimensions(array2, 1) \|\|
	!require_size(array2, size, 1)) SWIG_fail;
	arg2 = (double*) array_data(array2);
	arg3 = (int) array_size(array2,0);
	}
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND___call____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	double *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatDALinInterpolatedTableND___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const )arg1)->operator ()((double const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND___call____SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:FloatDALinInterpolatedTableND___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const )arg1)->operator ()((double const &)arg2,(double const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND___call____SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:FloatDALinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND___call____SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	double *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	double temp5 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:FloatDALinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "5"" of type '" "double""'");
	}
	temp5 = static_cast< double >(val5);
	arg5 = &temp5;
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4,(double const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND___call____SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double *arg4 = 0 ;
	double *arg5 = 0 ;
	double *arg6 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double temp4 ;
	double val4 ;
	int ecode4 = 0 ;
	double temp5 ;
	double val5 ;
	int ecode5 = 0 ;
	double temp6 ;
	double val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:FloatDALinInterpolatedTableND___call__",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "4"" of type '" "double""'");
	}
	temp4 = static_cast< double >(val4);
	arg4 = &temp4;
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "5"" of type '" "double""'");
	}
	temp5 = static_cast< double >(val5);
	arg5 = &temp5;
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FloatDALinInterpolatedTableND___call__" "', argument " "6"" of type '" "double""'");
	}
	temp6 = static_cast< double >(val6);
	arg6 = &temp6;
	{
	try {
	result = (float)((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const )arg1)->operator ()((double const &)arg2,(double const &)arg3,(double const &)arg4,(double const &)arg5,(double const &)arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND___call__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[7] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 6) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_FloatDALinInterpolatedTableND___call____SWIG_1(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = is_array(argv[1]) \|\| PySequence_Check(argv[1]);
	}
	if (_v) {
	if (argc <= 2) {
	return _wrap_FloatDALinInterpolatedTableND___call____SWIG_0(self, args);
	}
	return _wrap_FloatDALinInterpolatedTableND___call____SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_FloatDALinInterpolatedTableND___call____SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_FloatDALinInterpolatedTableND___call____SWIG_3(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_FloatDALinInterpolatedTableND___call____SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_FloatDALinInterpolatedTableND___call____SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatDALinInterpolatedTableND___call__'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::operator ()(double const *,unsigned int) const\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::operator ()(double const &) const\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::operator ()(double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::operator ()(double const &,double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::operator ()(double const &,double const &,double const &,double const &) const\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::operator ()(double const &,double const &,double const &,double const &,double const &) const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_dim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatDALinInterpolatedTableND_dim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND_dim" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *)arg1)->dim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_axes(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatDALinInterpolatedTableND_axes",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND_axes" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > ) &((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const )arg1)->axes();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_axis(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::DualAxis *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatDALinInterpolatedTableND_axis",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND_axis" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatDALinInterpolatedTableND_axis" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (npstat::DualAxis ) &((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const )arg1)->axis(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DualAxis, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_length(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatDALinInterpolatedTableND_length",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND_length" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *)arg1)->length();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_leftInterpolationLinear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatDALinInterpolatedTableND_leftInterpolationLinear",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND_leftInterpolationLinear" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatDALinInterpolatedTableND_leftInterpolationLinear" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *)arg1)->leftInterpolationLinear(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_rightInterpolationLinear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatDALinInterpolatedTableND_rightInterpolationLinear",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND_rightInterpolationLinear" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatDALinInterpolatedTableND_rightInterpolationLinear" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *)arg1)->rightInterpolationLinear(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_interpolationType(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatDALinInterpolatedTableND_interpolationType",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND_interpolationType" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	{
	try {
	result = ((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *)arg1)->interpolationType();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >(static_cast< const std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > >& >(result))), SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_functionLabel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::string *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatDALinInterpolatedTableND_functionLabel",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND_functionLabel" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (std::string ) &((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const )arg1)->functionLabel();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatDALinInterpolatedTableND_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND_table" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > ) &((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatDALinInterpolatedTableND_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND_table" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatDALinInterpolatedTableND_table__SWIG_1(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatDALinInterpolatedTableND_table__SWIG_0(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatDALinInterpolatedTableND_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::table() const\n"
	" npstat::LinInterpolatedTableND< float,npstat::DualAxis >::table()\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_getCoords(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	unsigned long arg2 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:FloatDALinInterpolatedTableND_getCoords",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND_getCoords" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatDALinInterpolatedTableND_getCoords" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FloatDALinInterpolatedTableND_getCoords" "', argument " "3"" of type '" "double *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatDALinInterpolatedTableND_getCoords" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *)arg1)->getCoords(arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_isUniformlyBinned(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatDALinInterpolatedTableND_isUniformlyBinned",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND_isUniformlyBinned" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *)arg1)->isUniformlyBinned();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_isWithinLimits(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyArrayObject *array2 = NULL ;
	int is_new_object2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatDALinInterpolatedTableND_isWithinLimits",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND_isWithinLimits" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	{
	npy_intp size[1] = {
	-1
	};
	array2 = obj_to_array_contiguous_allow_conversion(obj1,
	NPY_DOUBLE,
	&is_new_object2);
	if (!array2 \|\| !require_dimensions(array2, 1) \|\|
	!require_size(array2, size, 1)) SWIG_fail;
	arg2 = (double*) array_data(array2);
	arg3 = (int) array_size(array2,0);
	}
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const )arg1)->isWithinLimits((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_setFunctionLabel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	char arg2 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatDALinInterpolatedTableND_setFunctionLabel",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND_setFunctionLabel" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatDALinInterpolatedTableND_setFunctionLabel" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	{
	try {
	(arg1)->setFunctionLabel((char const *)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND___eq__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatDALinInterpolatedTableND___eq__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND___eq__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatDALinInterpolatedTableND___eq__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatDALinInterpolatedTableND___eq__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const &""'");
	}
	arg2 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const )arg1)->operator ==((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND___ne__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatDALinInterpolatedTableND___ne__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND___ne__" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatDALinInterpolatedTableND___ne__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatDALinInterpolatedTableND___ne__" "', argument " "2"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const &""'");
	}
	arg2 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const )arg1)->operator !=((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatDALinInterpolatedTableND_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND_classId" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	{
	try {
	result = ((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatDALinInterpolatedTableND_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND_write" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatDALinInterpolatedTableND_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatDALinInterpolatedTableND_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":FloatDALinInterpolatedTableND_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::LinInterpolatedTableND< float,npstat::DualAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":FloatDALinInterpolatedTableND_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::LinInterpolatedTableND< float,npstat::DualAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDALinInterpolatedTableND_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatDALinInterpolatedTableND_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDALinInterpolatedTableND_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatDALinInterpolatedTableND_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatDALinInterpolatedTableND_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatDALinInterpolatedTableND_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > )npstat::LinInterpolatedTableND< float,npstat::DualAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_FloatDALinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg1 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatDALinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatDALinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveRecord_DoubleLinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveRecord_DoubleLinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveRecord_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveRecord_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveRecord_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveRecord_DoubleLinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > )new gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > >((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveRecord_DoubleLinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > arg1 = (gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveRecord_DoubleLinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveRecord_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveRecord_DoubleLinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_Ref_DoubleLinInterpolatedTableND__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_DoubleLinInterpolatedTableND",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DoubleLinInterpolatedTableND__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_DoubleLinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_DoubleLinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DoubleLinInterpolatedTableND__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_DoubleLinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleLinInterpolatedTableND" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_DoubleLinInterpolatedTableND" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleLinInterpolatedTableND" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DoubleLinInterpolatedTableND(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_DoubleLinInterpolatedTableND__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_DoubleLinInterpolatedTableND__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_DoubleLinInterpolatedTableND__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_DoubleLinInterpolatedTableND'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_DoubleLinInterpolatedTableND_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > ) 0 ;
	unsigned long arg2 ;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > arg3 = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_DoubleLinInterpolatedTableND_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_DoubleLinInterpolatedTableND_restore" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_DoubleLinInterpolatedTableND_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_DoubleLinInterpolatedTableND_restore" "', argument " "3"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *""'");
	}
	arg3 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp3);
	{
	try {
	((gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_DoubleLinInterpolatedTableND_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_DoubleLinInterpolatedTableND_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_DoubleLinInterpolatedTableND_retrieve" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_DoubleLinInterpolatedTableND_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::UniformAxis > )gs_Reference_Sl_npstat_LinInterpolatedTableND_Sl_double_Sc_npstat_UniformAxis_Sg__Sg__retrieve((gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_DoubleLinInterpolatedTableND_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	SwigValueWrapper< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_DoubleLinInterpolatedTableND_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_DoubleLinInterpolatedTableND_getValue" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_DoubleLinInterpolatedTableND_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_npstat_LinInterpolatedTableND_Sl_double_Sc_npstat_UniformAxis_Sg__Sg__getValue((gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::LinInterpolatedTableND< double,npstat::UniformAxis >(static_cast< const npstat::LinInterpolatedTableND< double,npstat::UniformAxis >& >(result))), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_DoubleLinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_DoubleLinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_DoubleLinInterpolatedTableND" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_DoubleLinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPRecord__SWIG_65(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::UniformAxis > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPRecord",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPRecord" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPRecord" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR Record< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > >((npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > >(static_cast< const gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > >& >(result))), SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ArchiveRecord_DoubleNULinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveRecord_DoubleNULinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveRecord_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveRecord_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveRecord_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveRecord_DoubleNULinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > )new gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::GridAxis > >((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveRecord_DoubleNULinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > arg1 = (gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveRecord_DoubleNULinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveRecord_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveRecord_DoubleNULinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_Ref_DoubleNULinInterpolatedTableND__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_DoubleNULinInterpolatedTableND",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DoubleNULinInterpolatedTableND__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_DoubleNULinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_DoubleNULinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DoubleNULinInterpolatedTableND__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_DoubleNULinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleNULinInterpolatedTableND" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_DoubleNULinInterpolatedTableND" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleNULinInterpolatedTableND" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DoubleNULinInterpolatedTableND(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_DoubleNULinInterpolatedTableND__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_DoubleNULinInterpolatedTableND__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_DoubleNULinInterpolatedTableND__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_DoubleNULinInterpolatedTableND'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_DoubleNULinInterpolatedTableND_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > ) 0 ;
	unsigned long arg2 ;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > arg3 = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_DoubleNULinInterpolatedTableND_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_DoubleNULinInterpolatedTableND_restore" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_DoubleNULinInterpolatedTableND_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_DoubleNULinInterpolatedTableND_restore" "', argument " "3"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > *""'");
	}
	arg3 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp3);
	{
	try {
	((gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_DoubleNULinInterpolatedTableND_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_DoubleNULinInterpolatedTableND_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_DoubleNULinInterpolatedTableND_retrieve" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_DoubleNULinInterpolatedTableND_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::GridAxis > )gs_Reference_Sl_npstat_LinInterpolatedTableND_Sl_double_Sc_npstat_GridAxis_Sg__Sg__retrieve((gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_DoubleNULinInterpolatedTableND_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	SwigValueWrapper< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_DoubleNULinInterpolatedTableND_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_DoubleNULinInterpolatedTableND_getValue" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_DoubleNULinInterpolatedTableND_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_npstat_LinInterpolatedTableND_Sl_double_Sc_npstat_GridAxis_Sg__Sg__getValue((gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::LinInterpolatedTableND< double,npstat::GridAxis >(static_cast< const npstat::LinInterpolatedTableND< double,npstat::GridAxis >& >(result))), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_DoubleNULinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_DoubleNULinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_DoubleNULinInterpolatedTableND" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_DoubleNULinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPRecord__SWIG_66(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::GridAxis > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::GridAxis > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPRecord",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::GridAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::GridAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPRecord" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPRecord" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR Record< npstat::LinInterpolatedTableND< double,npstat::GridAxis > >((npstat::LinInterpolatedTableND< double,npstat::GridAxis > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::GridAxis > >(static_cast< const gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::GridAxis > >& >(result))), SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ArchiveRecord_DoubleDALinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveRecord_DoubleDALinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveRecord_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveRecord_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveRecord_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveRecord_DoubleDALinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > )new gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::DualAxis > >((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveRecord_DoubleDALinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > arg1 = (gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveRecord_DoubleDALinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveRecord_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveRecord_DoubleDALinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_Ref_DoubleDALinInterpolatedTableND__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_DoubleDALinInterpolatedTableND",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DoubleDALinInterpolatedTableND__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_DoubleDALinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_DoubleDALinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DoubleDALinInterpolatedTableND__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_DoubleDALinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleDALinInterpolatedTableND" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_DoubleDALinInterpolatedTableND" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleDALinInterpolatedTableND" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DoubleDALinInterpolatedTableND(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_DoubleDALinInterpolatedTableND__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_DoubleDALinInterpolatedTableND__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_DoubleDALinInterpolatedTableND__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_DoubleDALinInterpolatedTableND'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_DoubleDALinInterpolatedTableND_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > ) 0 ;
	unsigned long arg2 ;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > arg3 = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_DoubleDALinInterpolatedTableND_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_DoubleDALinInterpolatedTableND_restore" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_DoubleDALinInterpolatedTableND_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_DoubleDALinInterpolatedTableND_restore" "', argument " "3"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > *""'");
	}
	arg3 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp3);
	{
	try {
	((gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_DoubleDALinInterpolatedTableND_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_DoubleDALinInterpolatedTableND_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_DoubleDALinInterpolatedTableND_retrieve" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_DoubleDALinInterpolatedTableND_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< double,npstat::DualAxis > )gs_Reference_Sl_npstat_LinInterpolatedTableND_Sl_double_Sc_npstat_DualAxis_Sg__Sg__retrieve((gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_DoubleDALinInterpolatedTableND_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	SwigValueWrapper< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_DoubleDALinInterpolatedTableND_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_DoubleDALinInterpolatedTableND_getValue" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_DoubleDALinInterpolatedTableND_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_npstat_LinInterpolatedTableND_Sl_double_Sc_npstat_DualAxis_Sg__Sg__getValue((gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::LinInterpolatedTableND< double,npstat::DualAxis >(static_cast< const npstat::LinInterpolatedTableND< double,npstat::DualAxis >& >(result))), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_DoubleDALinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_DoubleDALinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_DoubleDALinInterpolatedTableND" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_DoubleDALinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPRecord__SWIG_67(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< double,npstat::DualAxis > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::DualAxis > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPRecord",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< double,npstat::DualAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< double,npstat::DualAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPRecord" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPRecord" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR Record< npstat::LinInterpolatedTableND< double,npstat::DualAxis > >((npstat::LinInterpolatedTableND< double,npstat::DualAxis > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::DualAxis > >(static_cast< const gs::ArchiveRecord< npstat::LinInterpolatedTableND< double,npstat::DualAxis > >& >(result))), SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ArchiveRecord_FloatLinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveRecord_FloatLinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveRecord_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveRecord_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveRecord_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveRecord_FloatLinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > )new gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > >((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveRecord_FloatLinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > arg1 = (gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveRecord_FloatLinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveRecord_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveRecord_FloatLinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_Ref_FloatLinInterpolatedTableND__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_FloatLinInterpolatedTableND",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_FloatLinInterpolatedTableND__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_FloatLinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_FloatLinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_FloatLinInterpolatedTableND__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_FloatLinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatLinInterpolatedTableND" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_FloatLinInterpolatedTableND" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatLinInterpolatedTableND" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_FloatLinInterpolatedTableND(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_FloatLinInterpolatedTableND__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_FloatLinInterpolatedTableND__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_FloatLinInterpolatedTableND__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_FloatLinInterpolatedTableND'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_FloatLinInterpolatedTableND_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > ) 0 ;
	unsigned long arg2 ;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > arg3 = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_FloatLinInterpolatedTableND_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_FloatLinInterpolatedTableND_restore" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_FloatLinInterpolatedTableND_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_FloatLinInterpolatedTableND_restore" "', argument " "3"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *""'");
	}
	arg3 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp3);
	{
	try {
	((gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_FloatLinInterpolatedTableND_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_FloatLinInterpolatedTableND_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_FloatLinInterpolatedTableND_retrieve" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_FloatLinInterpolatedTableND_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::UniformAxis > )gs_Reference_Sl_npstat_LinInterpolatedTableND_Sl_float_Sc_npstat_UniformAxis_Sg__Sg__retrieve((gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_FloatLinInterpolatedTableND_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	SwigValueWrapper< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_FloatLinInterpolatedTableND_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_FloatLinInterpolatedTableND_getValue" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_FloatLinInterpolatedTableND_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_npstat_LinInterpolatedTableND_Sl_float_Sc_npstat_UniformAxis_Sg__Sg__getValue((gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::LinInterpolatedTableND< float,npstat::UniformAxis >(static_cast< const npstat::LinInterpolatedTableND< float,npstat::UniformAxis >& >(result))), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_FloatLinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_FloatLinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_FloatLinInterpolatedTableND" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_FloatLinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPRecord__SWIG_68(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::UniformAxis > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPRecord",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPRecord" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPRecord" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR Record< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > >((npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > >(static_cast< const gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > >& >(result))), SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ArchiveRecord_FloatNULinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveRecord_FloatNULinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveRecord_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveRecord_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveRecord_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveRecord_FloatNULinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > )new gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::GridAxis > >((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveRecord_FloatNULinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > arg1 = (gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveRecord_FloatNULinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveRecord_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveRecord_FloatNULinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_Ref_FloatNULinInterpolatedTableND__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_FloatNULinInterpolatedTableND",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_FloatNULinInterpolatedTableND__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_FloatNULinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_FloatNULinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_FloatNULinInterpolatedTableND__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_FloatNULinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatNULinInterpolatedTableND" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_FloatNULinInterpolatedTableND" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatNULinInterpolatedTableND" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_FloatNULinInterpolatedTableND(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_FloatNULinInterpolatedTableND__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_FloatNULinInterpolatedTableND__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_FloatNULinInterpolatedTableND__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_FloatNULinInterpolatedTableND'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_FloatNULinInterpolatedTableND_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > ) 0 ;
	unsigned long arg2 ;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > arg3 = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_FloatNULinInterpolatedTableND_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_FloatNULinInterpolatedTableND_restore" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_FloatNULinInterpolatedTableND_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_FloatNULinInterpolatedTableND_restore" "', argument " "3"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > *""'");
	}
	arg3 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp3);
	{
	try {
	((gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_FloatNULinInterpolatedTableND_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_FloatNULinInterpolatedTableND_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_FloatNULinInterpolatedTableND_retrieve" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_FloatNULinInterpolatedTableND_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::GridAxis > )gs_Reference_Sl_npstat_LinInterpolatedTableND_Sl_float_Sc_npstat_GridAxis_Sg__Sg__retrieve((gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_FloatNULinInterpolatedTableND_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	SwigValueWrapper< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_FloatNULinInterpolatedTableND_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_FloatNULinInterpolatedTableND_getValue" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_FloatNULinInterpolatedTableND_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_npstat_LinInterpolatedTableND_Sl_float_Sc_npstat_GridAxis_Sg__Sg__getValue((gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::LinInterpolatedTableND< float,npstat::GridAxis >(static_cast< const npstat::LinInterpolatedTableND< float,npstat::GridAxis >& >(result))), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_FloatNULinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_FloatNULinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_FloatNULinInterpolatedTableND" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_FloatNULinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPRecord__SWIG_69(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::GridAxis > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::GridAxis > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPRecord",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::GridAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::GridAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPRecord" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPRecord" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR Record< npstat::LinInterpolatedTableND< float,npstat::GridAxis > >((npstat::LinInterpolatedTableND< float,npstat::GridAxis > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::GridAxis > >(static_cast< const gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::GridAxis > >& >(result))), SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ArchiveRecord_FloatDALinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveRecord_FloatDALinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveRecord_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveRecord_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveRecord_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveRecord_FloatDALinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > )new gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::DualAxis > >((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveRecord_FloatDALinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > arg1 = (gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveRecord_FloatDALinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveRecord_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveRecord_FloatDALinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_Ref_FloatDALinInterpolatedTableND__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_FloatDALinInterpolatedTableND",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_FloatDALinInterpolatedTableND__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_FloatDALinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_FloatDALinInterpolatedTableND" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_FloatDALinInterpolatedTableND__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_FloatDALinInterpolatedTableND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatDALinInterpolatedTableND" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_FloatDALinInterpolatedTableND" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatDALinInterpolatedTableND" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > )new gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_FloatDALinInterpolatedTableND(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_FloatDALinInterpolatedTableND__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_FloatDALinInterpolatedTableND__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_FloatDALinInterpolatedTableND__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_FloatDALinInterpolatedTableND'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_FloatDALinInterpolatedTableND_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > ) 0 ;
	unsigned long arg2 ;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > arg3 = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_FloatDALinInterpolatedTableND_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_FloatDALinInterpolatedTableND_restore" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_FloatDALinInterpolatedTableND_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_FloatDALinInterpolatedTableND_restore" "', argument " "3"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > *""'");
	}
	arg3 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp3);
	{
	try {
	((gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_FloatDALinInterpolatedTableND_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_FloatDALinInterpolatedTableND_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_FloatDALinInterpolatedTableND_retrieve" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_FloatDALinInterpolatedTableND_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (npstat::LinInterpolatedTableND< float,npstat::DualAxis > )gs_Reference_Sl_npstat_LinInterpolatedTableND_Sl_float_Sc_npstat_DualAxis_Sg__Sg__retrieve((gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_FloatDALinInterpolatedTableND_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	SwigValueWrapper< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_FloatDALinInterpolatedTableND_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_FloatDALinInterpolatedTableND_getValue" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_FloatDALinInterpolatedTableND_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_npstat_LinInterpolatedTableND_Sl_float_Sc_npstat_DualAxis_Sg__Sg__getValue((gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::LinInterpolatedTableND< float,npstat::DualAxis >(static_cast< const npstat::LinInterpolatedTableND< float,npstat::DualAxis >& >(result))), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_FloatDALinInterpolatedTableND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > arg1 = (gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_FloatDALinInterpolatedTableND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_FloatDALinInterpolatedTableND" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_FloatDALinInterpolatedTableND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPRecord__SWIG_70(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTableND< float,npstat::DualAxis > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::DualAxis > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPRecord",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::LinInterpolatedTableND< float,npstat::DualAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTableND< float,npstat::DualAxis > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPRecord" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPRecord" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR Record< npstat::LinInterpolatedTableND< float,npstat::DualAxis > >((npstat::LinInterpolatedTableND< float,npstat::DualAxis > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::DualAxis > >(static_cast< const gs::ArchiveRecord< npstat::LinInterpolatedTableND< float,npstat::DualAxis > >& >(result))), SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatUAInterpolationFunctor__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_FloatUAInterpolationFunctor",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > ptr = (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >((std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatUAInterpolationFunctor__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_FloatUAInterpolationFunctor",&obj0,&obj1)) SWIG_fail;
	{
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > ptr = (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >((std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatUAInterpolationFunctor__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	char arg4 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	int res4 ;
	char *buf4 = 0 ;
	int alloc4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_FloatUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "4"" of type '" "char const *""'");
	}
	arg4 = reinterpret_cast< char * >(buf4);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(char const *)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return resultobj;
	fail:
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatUAInterpolationFunctor__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_FloatUAInterpolationFunctor",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatUAInterpolationFunctor__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	char arg7 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	int res7 ;
	char *buf7 = 0 ;
	int alloc7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_FloatUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "7"" of type '" "char const *""'");
	}
	arg7 = reinterpret_cast< char * >(buf7);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(char const )arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return resultobj;
	fail:
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatUAInterpolationFunctor__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_FloatUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)*arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatUAInterpolationFunctor__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	char arg10 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	int res10 ;
	char *buf10 = 0 ;
	int alloc10 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_FloatUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "10"" of type '" "char const *""'");
	}
	arg10 = reinterpret_cast< char * >(buf10);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(char const *)arg10);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return resultobj;
	fail:
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatUAInterpolationFunctor__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_FloatUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatUAInterpolationFunctor__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::UniformAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	char arg13 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	int res13 ;
	char *buf13 = 0 ;
	int alloc13 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:new_FloatUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::UniformAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_AsCharPtrAndSize(obj12, &buf13, NULL, &alloc13);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "13"" of type '" "char const *""'");
	}
	arg13 = reinterpret_cast< char * >(buf13);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(npstat::UniformAxis const &)arg10,arg11,arg12,(char const )arg13);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return resultobj;
	fail:
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatUAInterpolationFunctor__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::UniformAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_FloatUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::UniformAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(npstat::UniformAxis const &)*arg10,arg11,arg12);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatUAInterpolationFunctor__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::UniformAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::UniformAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	char arg16 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	int res16 ;
	char *buf16 = 0 ;
	int alloc16 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	PyObject * obj15 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:new_FloatUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::UniformAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "13"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "13"" of type '" "npstat::UniformAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::UniformAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	res16 = SWIG_AsCharPtrAndSize(obj15, &buf16, NULL, &alloc16);
	if (!SWIG_IsOK(res16)) {
	SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "16"" of type '" "char const *""'");
	}
	arg16 = reinterpret_cast< char * >(buf16);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(npstat::UniformAxis const &)arg10,arg11,arg12,(npstat::UniformAxis const &)arg13,arg14,arg15,(char const *)arg16);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return resultobj;
	fail:
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatUAInterpolationFunctor__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::UniformAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::UniformAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:new_FloatUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::UniformAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "13"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatUAInterpolationFunctor" "', argument " "13"" of type '" "npstat::UniformAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::UniformAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FloatUAInterpolationFunctor" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(npstat::UniformAxis const &)arg10,arg11,arg12,(npstat::UniformAxis const &)arg13,arg14,arg15);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatUAInterpolationFunctor(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[17] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 16) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatUAInterpolationFunctor__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatUAInterpolationFunctor__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatUAInterpolationFunctor__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatUAInterpolationFunctor__SWIG_2(self, args);
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatUAInterpolationFunctor__SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[6], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatUAInterpolationFunctor__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 9) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatUAInterpolationFunctor__SWIG_7(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 10) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatUAInterpolationFunctor__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 12) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatUAInterpolationFunctor__SWIG_9(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 13) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[12], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatUAInterpolationFunctor__SWIG_8(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 15) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatUAInterpolationFunctor__SWIG_11(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 16) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[15], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatUAInterpolationFunctor__SWIG_10(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FloatUAInterpolationFunctor'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::StorableInterpolationFunctor(std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::StorableInterpolationFunctor(std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_FloatUAInterpolationFunctor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatUAInterpolationFunctor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAInterpolationFunctor_minDim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatUAInterpolationFunctor_minDim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAInterpolationFunctor_minDim" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > const *)arg1)->minDim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAInterpolationFunctor___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:FloatUAInterpolationFunctor___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAInterpolationFunctor___call__" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatUAInterpolationFunctor___call__" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatUAInterpolationFunctor___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAInterpolationFunctor_interpolator__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatUAInterpolationFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAInterpolationFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::Table *) &(arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAInterpolationFunctor_interpolator__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatUAInterpolationFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAInterpolationFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::Table ) &((npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > const )arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAInterpolationFunctor_interpolator(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatUAInterpolationFunctor_interpolator__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatUAInterpolationFunctor_interpolator__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatUAInterpolationFunctor_interpolator'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::interpolator()\n"
	" npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::interpolator() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatUAInterpolationFunctor_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatUAInterpolationFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAInterpolationFunctor_table" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAInterpolationFunctor_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatUAInterpolationFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAInterpolationFunctor_table" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > ) &((npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAInterpolationFunctor_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatUAInterpolationFunctor_table__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatUAInterpolationFunctor_table__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatUAInterpolationFunctor_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::table()\n"
	" npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::table() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatUAInterpolationFunctor_setConverter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > ) 0 ;
	npstat::Same< float > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatUAInterpolationFunctor_setConverter",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAInterpolationFunctor_setConverter" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__SameT_float_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatUAInterpolationFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< float > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatUAInterpolationFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< float > const &""'");
	}
	arg2 = reinterpret_cast< npstat::Same< float > * >(argp2);
	{
	try {
	(arg1)->setConverter((npstat::Same< float > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAInterpolationFunctor_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatUAInterpolationFunctor_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAInterpolationFunctor_classId" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = ((npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAInterpolationFunctor_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatUAInterpolationFunctor_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAInterpolationFunctor_write" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatUAInterpolationFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatUAInterpolationFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAInterpolationFunctor_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":FloatUAInterpolationFunctor_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAInterpolationFunctor_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":FloatUAInterpolationFunctor_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAInterpolationFunctor_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatUAInterpolationFunctor_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAInterpolationFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatUAInterpolationFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatUAInterpolationFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatUAInterpolationFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::UniformAxis > )npstat::StorableInterpolationFunctor< float,npstat::UniformAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatUAInterpolationFunctor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__UniformAxis_npstat__SameT_float_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_FloatNUInterpolationFunctor__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_FloatNUInterpolationFunctor",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > ptr = (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< float,npstat::GridAxis >((std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNUInterpolationFunctor__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_FloatNUInterpolationFunctor",&obj0,&obj1)) SWIG_fail;
	{
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > ptr = (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< float,npstat::GridAxis >((std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNUInterpolationFunctor__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	char arg4 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	int res4 ;
	char *buf4 = 0 ;
	int alloc4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_FloatNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "4"" of type '" "char const *""'");
	}
	arg4 = reinterpret_cast< char * >(buf4);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(char const *)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return resultobj;
	fail:
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNUInterpolationFunctor__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_FloatNUInterpolationFunctor",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNUInterpolationFunctor__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	char arg7 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	int res7 ;
	char *buf7 = 0 ;
	int alloc7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_FloatNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "7"" of type '" "char const *""'");
	}
	arg7 = reinterpret_cast< char * >(buf7);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(char const )arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return resultobj;
	fail:
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNUInterpolationFunctor__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_FloatNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)*arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNUInterpolationFunctor__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	char arg10 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	int res10 ;
	char *buf10 = 0 ;
	int alloc10 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_FloatNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "10"" of type '" "char const *""'");
	}
	arg10 = reinterpret_cast< char * >(buf10);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(char const *)arg10);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return resultobj;
	fail:
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNUInterpolationFunctor__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_FloatNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNUInterpolationFunctor__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::GridAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	char arg13 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	int res13 ;
	char *buf13 = 0 ;
	int alloc13 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:new_FloatNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::GridAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_AsCharPtrAndSize(obj12, &buf13, NULL, &alloc13);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "13"" of type '" "char const *""'");
	}
	arg13 = reinterpret_cast< char * >(buf13);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(npstat::GridAxis const &)arg10,arg11,arg12,(char const )arg13);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return resultobj;
	fail:
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNUInterpolationFunctor__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::GridAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_FloatNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::GridAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(npstat::GridAxis const &)*arg10,arg11,arg12);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNUInterpolationFunctor__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::GridAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::GridAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	char arg16 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	int res16 ;
	char *buf16 = 0 ;
	int alloc16 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	PyObject * obj15 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:new_FloatNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::GridAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "13"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "13"" of type '" "npstat::GridAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::GridAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	res16 = SWIG_AsCharPtrAndSize(obj15, &buf16, NULL, &alloc16);
	if (!SWIG_IsOK(res16)) {
	SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "16"" of type '" "char const *""'");
	}
	arg16 = reinterpret_cast< char * >(buf16);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(npstat::GridAxis const &)arg10,arg11,arg12,(npstat::GridAxis const &)arg13,arg14,arg15,(char const *)arg16);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return resultobj;
	fail:
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNUInterpolationFunctor__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::GridAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::GridAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:new_FloatNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::GridAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "13"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatNUInterpolationFunctor" "', argument " "13"" of type '" "npstat::GridAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::GridAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FloatNUInterpolationFunctor" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< float,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(npstat::GridAxis const &)arg10,arg11,arg12,(npstat::GridAxis const &)arg13,arg14,arg15);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatNUInterpolationFunctor(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[17] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 16) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatNUInterpolationFunctor__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatNUInterpolationFunctor__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatNUInterpolationFunctor__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatNUInterpolationFunctor__SWIG_2(self, args);
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatNUInterpolationFunctor__SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[6], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatNUInterpolationFunctor__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 9) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatNUInterpolationFunctor__SWIG_7(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 10) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatNUInterpolationFunctor__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 12) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatNUInterpolationFunctor__SWIG_9(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 13) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[12], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatNUInterpolationFunctor__SWIG_8(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 15) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatNUInterpolationFunctor__SWIG_11(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 16) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[15], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatNUInterpolationFunctor__SWIG_10(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FloatNUInterpolationFunctor'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::StorableInterpolationFunctor(std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::StorableInterpolationFunctor(std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_FloatNUInterpolationFunctor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatNUInterpolationFunctor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::GridAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUInterpolationFunctor_minDim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNUInterpolationFunctor_minDim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUInterpolationFunctor_minDim" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableInterpolationFunctor< float,npstat::GridAxis > const *)arg1)->minDim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUInterpolationFunctor___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:FloatNUInterpolationFunctor___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUInterpolationFunctor___call__" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::GridAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatNUInterpolationFunctor___call__" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatNUInterpolationFunctor___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::StorableInterpolationFunctor< float,npstat::GridAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUInterpolationFunctor_interpolator__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNUInterpolationFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUInterpolationFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::Table *) &(arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUInterpolationFunctor_interpolator__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNUInterpolationFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUInterpolationFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::Table ) &((npstat::StorableInterpolationFunctor< float,npstat::GridAxis > const )arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUInterpolationFunctor_interpolator(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatNUInterpolationFunctor_interpolator__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatNUInterpolationFunctor_interpolator__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatNUInterpolationFunctor_interpolator'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::interpolator()\n"
	" npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::interpolator() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatNUInterpolationFunctor_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNUInterpolationFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUInterpolationFunctor_table" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUInterpolationFunctor_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNUInterpolationFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUInterpolationFunctor_table" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > ) &((npstat::StorableInterpolationFunctor< float,npstat::GridAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUInterpolationFunctor_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatNUInterpolationFunctor_table__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatNUInterpolationFunctor_table__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatNUInterpolationFunctor_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::table()\n"
	" npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::table() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatNUInterpolationFunctor_setConverter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > ) 0 ;
	npstat::Same< float > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNUInterpolationFunctor_setConverter",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUInterpolationFunctor_setConverter" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::GridAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__SameT_float_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatNUInterpolationFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< float > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatNUInterpolationFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< float > const &""'");
	}
	arg2 = reinterpret_cast< npstat::Same< float > * >(argp2);
	{
	try {
	(arg1)->setConverter((npstat::Same< float > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUInterpolationFunctor_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNUInterpolationFunctor_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUInterpolationFunctor_classId" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::GridAxis > * >(argp1);
	{
	try {
	result = ((npstat::StorableInterpolationFunctor< float,npstat::GridAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUInterpolationFunctor_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNUInterpolationFunctor_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUInterpolationFunctor_write" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::GridAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatNUInterpolationFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatNUInterpolationFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::StorableInterpolationFunctor< float,npstat::GridAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUInterpolationFunctor_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":FloatNUInterpolationFunctor_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUInterpolationFunctor_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":FloatNUInterpolationFunctor_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUInterpolationFunctor_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNUInterpolationFunctor_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUInterpolationFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatNUInterpolationFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatNUInterpolationFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatNUInterpolationFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::GridAxis > )npstat::StorableInterpolationFunctor< float,npstat::GridAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatNUInterpolationFunctor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__GridAxis_npstat__SameT_float_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_FloatInterpolationFunctor__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_FloatInterpolationFunctor",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > ptr = (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FloatInterpolationFunctor" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< float,npstat::DualAxis >((std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatInterpolationFunctor__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_FloatInterpolationFunctor",&obj0,&obj1)) SWIG_fail;
	{
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > ptr = (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< float,npstat::DualAxis >((std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatInterpolationFunctor__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	char arg4 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	int res4 ;
	char *buf4 = 0 ;
	int alloc4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_FloatInterpolationFunctor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatInterpolationFunctor" "', argument " "4"" of type '" "char const *""'");
	}
	arg4 = reinterpret_cast< char * >(buf4);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(char const *)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return resultobj;
	fail:
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatInterpolationFunctor__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_FloatInterpolationFunctor",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatInterpolationFunctor__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	char arg7 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	int res7 ;
	char *buf7 = 0 ;
	int alloc7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_FloatInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatInterpolationFunctor" "', argument " "7"" of type '" "char const *""'");
	}
	arg7 = reinterpret_cast< char * >(buf7);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(char const )arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return resultobj;
	fail:
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatInterpolationFunctor__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_FloatInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)*arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatInterpolationFunctor__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	char arg10 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	int res10 ;
	char *buf10 = 0 ;
	int alloc10 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_FloatInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatInterpolationFunctor" "', argument " "10"" of type '" "char const *""'");
	}
	arg10 = reinterpret_cast< char * >(buf10);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(char const *)arg10);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return resultobj;
	fail:
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatInterpolationFunctor__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_FloatInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatInterpolationFunctor__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::DualAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	char arg13 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	int res13 ;
	char *buf13 = 0 ;
	int alloc13 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:new_FloatInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatInterpolationFunctor" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::DualAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_AsCharPtrAndSize(obj12, &buf13, NULL, &alloc13);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatInterpolationFunctor" "', argument " "13"" of type '" "char const *""'");
	}
	arg13 = reinterpret_cast< char * >(buf13);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(npstat::DualAxis const &)arg10,arg11,arg12,(char const )arg13);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return resultobj;
	fail:
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatInterpolationFunctor__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::DualAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_FloatInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatInterpolationFunctor" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::DualAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(npstat::DualAxis const &)*arg10,arg11,arg12);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatInterpolationFunctor__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::DualAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::DualAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	char arg16 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	int res16 ;
	char *buf16 = 0 ;
	int alloc16 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	PyObject * obj15 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:new_FloatInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatInterpolationFunctor" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::DualAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatInterpolationFunctor" "', argument " "13"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "13"" of type '" "npstat::DualAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::DualAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FloatInterpolationFunctor" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FloatInterpolationFunctor" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	res16 = SWIG_AsCharPtrAndSize(obj15, &buf16, NULL, &alloc16);
	if (!SWIG_IsOK(res16)) {
	SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_FloatInterpolationFunctor" "', argument " "16"" of type '" "char const *""'");
	}
	arg16 = reinterpret_cast< char * >(buf16);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(npstat::DualAxis const &)arg10,arg11,arg12,(npstat::DualAxis const &)arg13,arg14,arg15,(char const *)arg16);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return resultobj;
	fail:
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatInterpolationFunctor__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::DualAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::DualAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:new_FloatInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FloatInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FloatInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_FloatInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_FloatInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_FloatInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_FloatInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_FloatInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_FloatInterpolationFunctor" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::DualAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_FloatInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_FloatInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_FloatInterpolationFunctor" "', argument " "13"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatInterpolationFunctor" "', argument " "13"" of type '" "npstat::DualAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::DualAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_FloatInterpolationFunctor" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_FloatInterpolationFunctor" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< float,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(npstat::DualAxis const &)arg10,arg11,arg12,(npstat::DualAxis const &)arg13,arg14,arg15);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatInterpolationFunctor(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[17] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 16) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatInterpolationFunctor__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatInterpolationFunctor__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatInterpolationFunctor__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatInterpolationFunctor__SWIG_2(self, args);
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatInterpolationFunctor__SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[6], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatInterpolationFunctor__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 9) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatInterpolationFunctor__SWIG_7(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 10) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatInterpolationFunctor__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 12) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatInterpolationFunctor__SWIG_9(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 13) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[12], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatInterpolationFunctor__SWIG_8(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 15) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatInterpolationFunctor__SWIG_11(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 16) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[15], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatInterpolationFunctor__SWIG_10(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FloatInterpolationFunctor'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::StorableInterpolationFunctor(std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::StorableInterpolationFunctor(std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_FloatInterpolationFunctor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatInterpolationFunctor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatInterpolationFunctor" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::DualAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatInterpolationFunctor_minDim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatInterpolationFunctor_minDim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatInterpolationFunctor_minDim" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableInterpolationFunctor< float,npstat::DualAxis > const *)arg1)->minDim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatInterpolationFunctor___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:FloatInterpolationFunctor___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatInterpolationFunctor___call__" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatInterpolationFunctor___call__" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatInterpolationFunctor___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::StorableInterpolationFunctor< float,npstat::DualAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatInterpolationFunctor_interpolator__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatInterpolationFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatInterpolationFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::Table *) &(arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatInterpolationFunctor_interpolator__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatInterpolationFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatInterpolationFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::Table ) &((npstat::StorableInterpolationFunctor< float,npstat::DualAxis > const )arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatInterpolationFunctor_interpolator(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatInterpolationFunctor_interpolator__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatInterpolationFunctor_interpolator__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatInterpolationFunctor_interpolator'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::interpolator()\n"
	" npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::interpolator() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatInterpolationFunctor_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatInterpolationFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatInterpolationFunctor_table" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatInterpolationFunctor_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatInterpolationFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatInterpolationFunctor_table" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > ) &((npstat::StorableInterpolationFunctor< float,npstat::DualAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatInterpolationFunctor_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatInterpolationFunctor_table__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatInterpolationFunctor_table__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatInterpolationFunctor_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::table()\n"
	" npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::table() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatInterpolationFunctor_setConverter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > ) 0 ;
	npstat::Same< float > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatInterpolationFunctor_setConverter",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatInterpolationFunctor_setConverter" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__SameT_float_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatInterpolationFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< float > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatInterpolationFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< float > const &""'");
	}
	arg2 = reinterpret_cast< npstat::Same< float > * >(argp2);
	{
	try {
	(arg1)->setConverter((npstat::Same< float > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatInterpolationFunctor_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatInterpolationFunctor_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatInterpolationFunctor_classId" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::DualAxis > * >(argp1);
	{
	try {
	result = ((npstat::StorableInterpolationFunctor< float,npstat::DualAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatInterpolationFunctor_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatInterpolationFunctor_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatInterpolationFunctor_write" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< float,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< float,npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatInterpolationFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatInterpolationFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::StorableInterpolationFunctor< float,npstat::DualAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatInterpolationFunctor_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":FloatInterpolationFunctor_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatInterpolationFunctor_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":FloatInterpolationFunctor_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatInterpolationFunctor_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableInterpolationFunctor< float,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatInterpolationFunctor_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatInterpolationFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatInterpolationFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatInterpolationFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatInterpolationFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< float,npstat::DualAxis > )npstat::StorableInterpolationFunctor< float,npstat::DualAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatInterpolationFunctor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__StorableInterpolationFunctorT_float_npstat__DualAxis_npstat__SameT_float_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DoubleUAInterpolationFunctor__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DoubleUAInterpolationFunctor",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > ptr = (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >((std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleUAInterpolationFunctor__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_DoubleUAInterpolationFunctor",&obj0,&obj1)) SWIG_fail;
	{
	std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > ptr = (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >((std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleUAInterpolationFunctor__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	char arg4 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	int res4 ;
	char *buf4 = 0 ;
	int alloc4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_DoubleUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "4"" of type '" "char const *""'");
	}
	arg4 = reinterpret_cast< char * >(buf4);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(char const *)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return resultobj;
	fail:
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleUAInterpolationFunctor__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DoubleUAInterpolationFunctor",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleUAInterpolationFunctor__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	char arg7 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	int res7 ;
	char *buf7 = 0 ;
	int alloc7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_DoubleUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "7"" of type '" "char const *""'");
	}
	arg7 = reinterpret_cast< char * >(buf7);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(char const )arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return resultobj;
	fail:
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleUAInterpolationFunctor__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_DoubleUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)*arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleUAInterpolationFunctor__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	char arg10 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	int res10 ;
	char *buf10 = 0 ;
	int alloc10 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_DoubleUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "10"" of type '" "char const *""'");
	}
	arg10 = reinterpret_cast< char * >(buf10);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(char const *)arg10);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return resultobj;
	fail:
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleUAInterpolationFunctor__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_DoubleUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleUAInterpolationFunctor__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::UniformAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	char arg13 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	int res13 ;
	char *buf13 = 0 ;
	int alloc13 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:new_DoubleUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::UniformAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_AsCharPtrAndSize(obj12, &buf13, NULL, &alloc13);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "13"" of type '" "char const *""'");
	}
	arg13 = reinterpret_cast< char * >(buf13);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(npstat::UniformAxis const &)arg10,arg11,arg12,(char const )arg13);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return resultobj;
	fail:
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleUAInterpolationFunctor__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::UniformAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_DoubleUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::UniformAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(npstat::UniformAxis const &)*arg10,arg11,arg12);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleUAInterpolationFunctor__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::UniformAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::UniformAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	char arg16 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	int res16 ;
	char *buf16 = 0 ;
	int alloc16 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	PyObject * obj15 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:new_DoubleUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::UniformAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "13"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "13"" of type '" "npstat::UniformAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::UniformAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	res16 = SWIG_AsCharPtrAndSize(obj15, &buf16, NULL, &alloc16);
	if (!SWIG_IsOK(res16)) {
	SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "16"" of type '" "char const *""'");
	}
	arg16 = reinterpret_cast< char * >(buf16);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(npstat::UniformAxis const &)arg10,arg11,arg12,(npstat::UniformAxis const &)arg13,arg14,arg15,(char const *)arg16);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return resultobj;
	fail:
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleUAInterpolationFunctor__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::UniformAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::UniformAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::UniformAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::UniformAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:new_DoubleUAInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "4"" of type '" "npstat::UniformAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::UniformAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "7"" of type '" "npstat::UniformAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::UniformAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "10"" of type '" "npstat::UniformAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::UniformAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "13"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "13"" of type '" "npstat::UniformAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::UniformAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_DoubleUAInterpolationFunctor" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > )new npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >((npstat::UniformAxis const &)arg1,arg2,arg3,(npstat::UniformAxis const &)arg4,arg5,arg6,(npstat::UniformAxis const &)arg7,arg8,arg9,(npstat::UniformAxis const &)arg10,arg11,arg12,(npstat::UniformAxis const &)arg13,arg14,arg15);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleUAInterpolationFunctor(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[17] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 16) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleUAInterpolationFunctor__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleUAInterpolationFunctor__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleUAInterpolationFunctor__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleUAInterpolationFunctor__SWIG_2(self, args);
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleUAInterpolationFunctor__SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[6], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleUAInterpolationFunctor__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 9) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleUAInterpolationFunctor__SWIG_7(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 10) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleUAInterpolationFunctor__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 12) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleUAInterpolationFunctor__SWIG_9(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 13) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[12], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleUAInterpolationFunctor__SWIG_8(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 15) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleUAInterpolationFunctor__SWIG_11(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 16) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[15], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleUAInterpolationFunctor__SWIG_10(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DoubleUAInterpolationFunctor'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::StorableInterpolationFunctor(std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::StorableInterpolationFunctor(std::vector< npstat::UniformAxis,std::allocator< npstat::UniformAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::StorableInterpolationFunctor(npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool,npstat::UniformAxis const &,bool,bool)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_DoubleUAInterpolationFunctor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleUAInterpolationFunctor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleUAInterpolationFunctor" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAInterpolationFunctor_minDim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleUAInterpolationFunctor_minDim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAInterpolationFunctor_minDim" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > const *)arg1)->minDim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAInterpolationFunctor___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleUAInterpolationFunctor___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAInterpolationFunctor___call__" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleUAInterpolationFunctor___call__" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleUAInterpolationFunctor___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAInterpolationFunctor_interpolator__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleUAInterpolationFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAInterpolationFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::Table *) &(arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAInterpolationFunctor_interpolator__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleUAInterpolationFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAInterpolationFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::Table ) &((npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > const )arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAInterpolationFunctor_interpolator(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleUAInterpolationFunctor_interpolator__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleUAInterpolationFunctor_interpolator__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleUAInterpolationFunctor_interpolator'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::interpolator()\n"
	" npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::interpolator() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleUAInterpolationFunctor_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleUAInterpolationFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAInterpolationFunctor_table" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAInterpolationFunctor_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleUAInterpolationFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAInterpolationFunctor_table" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > ) &((npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAInterpolationFunctor_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleUAInterpolationFunctor_table__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleUAInterpolationFunctor_table__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleUAInterpolationFunctor_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::table()\n"
	" npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::table() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleUAInterpolationFunctor_setConverter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > ) 0 ;
	npstat::Same< double > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleUAInterpolationFunctor_setConverter",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAInterpolationFunctor_setConverter" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__SameT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleUAInterpolationFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleUAInterpolationFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::Same< double > * >(argp2);
	{
	try {
	(arg1)->setConverter((npstat::Same< double > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAInterpolationFunctor_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleUAInterpolationFunctor_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAInterpolationFunctor_classId" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > * >(argp1);
	{
	try {
	result = ((npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAInterpolationFunctor_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleUAInterpolationFunctor_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAInterpolationFunctor_write" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleUAInterpolationFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleUAInterpolationFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAInterpolationFunctor_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":DoubleUAInterpolationFunctor_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAInterpolationFunctor_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":DoubleUAInterpolationFunctor_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAInterpolationFunctor_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleUAInterpolationFunctor_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAInterpolationFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleUAInterpolationFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleUAInterpolationFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleUAInterpolationFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::UniformAxis > )npstat::StorableInterpolationFunctor< double,npstat::UniformAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleUAInterpolationFunctor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__UniformAxis_npstat__SameT_double_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DoubleNUInterpolationFunctor__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DoubleNUInterpolationFunctor",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > ptr = (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< double,npstat::GridAxis >((std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNUInterpolationFunctor__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_DoubleNUInterpolationFunctor",&obj0,&obj1)) SWIG_fail;
	{
	std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > ptr = (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< double,npstat::GridAxis >((std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNUInterpolationFunctor__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	char arg4 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	int res4 ;
	char *buf4 = 0 ;
	int alloc4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_DoubleNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "4"" of type '" "char const *""'");
	}
	arg4 = reinterpret_cast< char * >(buf4);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(char const *)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return resultobj;
	fail:
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNUInterpolationFunctor__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DoubleNUInterpolationFunctor",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNUInterpolationFunctor__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	char arg7 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	int res7 ;
	char *buf7 = 0 ;
	int alloc7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_DoubleNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "7"" of type '" "char const *""'");
	}
	arg7 = reinterpret_cast< char * >(buf7);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(char const )arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return resultobj;
	fail:
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNUInterpolationFunctor__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_DoubleNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)*arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNUInterpolationFunctor__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	char arg10 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	int res10 ;
	char *buf10 = 0 ;
	int alloc10 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_DoubleNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "10"" of type '" "char const *""'");
	}
	arg10 = reinterpret_cast< char * >(buf10);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(char const *)arg10);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return resultobj;
	fail:
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNUInterpolationFunctor__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_DoubleNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNUInterpolationFunctor__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::GridAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	char arg13 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	int res13 ;
	char *buf13 = 0 ;
	int alloc13 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:new_DoubleNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::GridAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_AsCharPtrAndSize(obj12, &buf13, NULL, &alloc13);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "13"" of type '" "char const *""'");
	}
	arg13 = reinterpret_cast< char * >(buf13);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(npstat::GridAxis const &)arg10,arg11,arg12,(char const )arg13);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return resultobj;
	fail:
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNUInterpolationFunctor__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::GridAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_DoubleNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::GridAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(npstat::GridAxis const &)*arg10,arg11,arg12);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNUInterpolationFunctor__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::GridAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::GridAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	char arg16 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	int res16 ;
	char *buf16 = 0 ;
	int alloc16 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	PyObject * obj15 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:new_DoubleNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::GridAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "13"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "13"" of type '" "npstat::GridAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::GridAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	res16 = SWIG_AsCharPtrAndSize(obj15, &buf16, NULL, &alloc16);
	if (!SWIG_IsOK(res16)) {
	SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "16"" of type '" "char const *""'");
	}
	arg16 = reinterpret_cast< char * >(buf16);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(npstat::GridAxis const &)arg10,arg11,arg12,(npstat::GridAxis const &)arg13,arg14,arg15,(char const *)arg16);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return resultobj;
	fail:
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNUInterpolationFunctor__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::GridAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::GridAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::GridAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::GridAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:new_DoubleNUInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "4"" of type '" "npstat::GridAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::GridAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "7"" of type '" "npstat::GridAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::GridAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "10"" of type '" "npstat::GridAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::GridAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "13"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "13"" of type '" "npstat::GridAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::GridAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_DoubleNUInterpolationFunctor" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > )new npstat::StorableInterpolationFunctor< double,npstat::GridAxis >((npstat::GridAxis const &)arg1,arg2,arg3,(npstat::GridAxis const &)arg4,arg5,arg6,(npstat::GridAxis const &)arg7,arg8,arg9,(npstat::GridAxis const &)arg10,arg11,arg12,(npstat::GridAxis const &)arg13,arg14,arg15);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleNUInterpolationFunctor(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[17] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 16) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleNUInterpolationFunctor__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleNUInterpolationFunctor__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleNUInterpolationFunctor__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleNUInterpolationFunctor__SWIG_2(self, args);
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleNUInterpolationFunctor__SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[6], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleNUInterpolationFunctor__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 9) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleNUInterpolationFunctor__SWIG_7(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 10) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleNUInterpolationFunctor__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 12) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleNUInterpolationFunctor__SWIG_9(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 13) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[12], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleNUInterpolationFunctor__SWIG_8(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 15) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleNUInterpolationFunctor__SWIG_11(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 16) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[15], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleNUInterpolationFunctor__SWIG_10(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DoubleNUInterpolationFunctor'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::StorableInterpolationFunctor(std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::StorableInterpolationFunctor(std::vector< npstat::GridAxis,std::allocator< npstat::GridAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::StorableInterpolationFunctor(npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool,npstat::GridAxis const &,bool,bool)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_DoubleNUInterpolationFunctor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleNUInterpolationFunctor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleNUInterpolationFunctor" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::GridAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUInterpolationFunctor_minDim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNUInterpolationFunctor_minDim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUInterpolationFunctor_minDim" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableInterpolationFunctor< double,npstat::GridAxis > const *)arg1)->minDim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUInterpolationFunctor___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleNUInterpolationFunctor___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUInterpolationFunctor___call__" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::GridAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleNUInterpolationFunctor___call__" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleNUInterpolationFunctor___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::StorableInterpolationFunctor< double,npstat::GridAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUInterpolationFunctor_interpolator__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNUInterpolationFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUInterpolationFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::Table *) &(arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUInterpolationFunctor_interpolator__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNUInterpolationFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUInterpolationFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::Table ) &((npstat::StorableInterpolationFunctor< double,npstat::GridAxis > const )arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUInterpolationFunctor_interpolator(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleNUInterpolationFunctor_interpolator__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleNUInterpolationFunctor_interpolator__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleNUInterpolationFunctor_interpolator'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::interpolator()\n"
	" npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::interpolator() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleNUInterpolationFunctor_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNUInterpolationFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUInterpolationFunctor_table" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUInterpolationFunctor_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNUInterpolationFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUInterpolationFunctor_table" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::GridAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > ) &((npstat::StorableInterpolationFunctor< double,npstat::GridAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUInterpolationFunctor_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleNUInterpolationFunctor_table__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleNUInterpolationFunctor_table__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleNUInterpolationFunctor_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::table()\n"
	" npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::table() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleNUInterpolationFunctor_setConverter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > ) 0 ;
	npstat::Same< double > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNUInterpolationFunctor_setConverter",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUInterpolationFunctor_setConverter" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::GridAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__SameT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleNUInterpolationFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleNUInterpolationFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::Same< double > * >(argp2);
	{
	try {
	(arg1)->setConverter((npstat::Same< double > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUInterpolationFunctor_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNUInterpolationFunctor_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUInterpolationFunctor_classId" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::GridAxis > * >(argp1);
	{
	try {
	result = ((npstat::StorableInterpolationFunctor< double,npstat::GridAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUInterpolationFunctor_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNUInterpolationFunctor_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUInterpolationFunctor_write" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::GridAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::GridAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleNUInterpolationFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleNUInterpolationFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::StorableInterpolationFunctor< double,npstat::GridAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUInterpolationFunctor_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":DoubleNUInterpolationFunctor_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUInterpolationFunctor_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":DoubleNUInterpolationFunctor_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUInterpolationFunctor_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::GridAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNUInterpolationFunctor_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUInterpolationFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleNUInterpolationFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleNUInterpolationFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleNUInterpolationFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::GridAxis > )npstat::StorableInterpolationFunctor< double,npstat::GridAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleNUInterpolationFunctor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__GridAxis_npstat__SameT_double_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DoubleInterpolationFunctor__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DoubleInterpolationFunctor",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > ptr = (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DoubleInterpolationFunctor" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< double,npstat::DualAxis >((std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleInterpolationFunctor__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > *arg1 = 0 ;
	std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > *arg2 = 0 ;
	int res1 = SWIG_OLDOBJ ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_DoubleInterpolationFunctor",&obj0,&obj1)) SWIG_fail;
	{
	std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > ptr = (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "2"" of type '" "std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &""'");
	}
	arg2 = reinterpret_cast< std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > * >(argp2);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< double,npstat::DualAxis >((std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &)arg1,(std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleInterpolationFunctor__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	char arg4 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	int res4 ;
	char *buf4 = 0 ;
	int alloc4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_DoubleInterpolationFunctor",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleInterpolationFunctor" "', argument " "4"" of type '" "char const *""'");
	}
	arg4 = reinterpret_cast< char * >(buf4);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(char const *)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return resultobj;
	fail:
	if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleInterpolationFunctor__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DoubleInterpolationFunctor",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleInterpolationFunctor__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	char arg7 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	int res7 ;
	char *buf7 = 0 ;
	int alloc7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_DoubleInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleInterpolationFunctor" "', argument " "7"" of type '" "char const *""'");
	}
	arg7 = reinterpret_cast< char * >(buf7);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(char const )arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return resultobj;
	fail:
	if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleInterpolationFunctor__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_DoubleInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)*arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleInterpolationFunctor__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	char arg10 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	int res10 ;
	char *buf10 = 0 ;
	int alloc10 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:new_DoubleInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_AsCharPtrAndSize(obj9, &buf10, NULL, &alloc10);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleInterpolationFunctor" "', argument " "10"" of type '" "char const *""'");
	}
	arg10 = reinterpret_cast< char * >(buf10);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(char const *)arg10);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return resultobj;
	fail:
	if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleInterpolationFunctor__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_DoubleInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleInterpolationFunctor__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::DualAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	char arg13 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	int res13 ;
	char *buf13 = 0 ;
	int alloc13 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOO:new_DoubleInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleInterpolationFunctor" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::DualAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_AsCharPtrAndSize(obj12, &buf13, NULL, &alloc13);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleInterpolationFunctor" "', argument " "13"" of type '" "char const *""'");
	}
	arg13 = reinterpret_cast< char * >(buf13);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(npstat::DualAxis const &)arg10,arg11,arg12,(char const )arg13);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return resultobj;
	fail:
	if (alloc13 == SWIG_NEWOBJ) delete[] buf13;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleInterpolationFunctor__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::DualAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:new_DoubleInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleInterpolationFunctor" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::DualAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(npstat::DualAxis const &)*arg10,arg11,arg12);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleInterpolationFunctor__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::DualAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::DualAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	char arg16 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	int res16 ;
	char *buf16 = 0 ;
	int alloc16 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	PyObject * obj15 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOOO:new_DoubleInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14,&obj15)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleInterpolationFunctor" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::DualAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleInterpolationFunctor" "', argument " "13"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "13"" of type '" "npstat::DualAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::DualAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_DoubleInterpolationFunctor" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_DoubleInterpolationFunctor" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	res16 = SWIG_AsCharPtrAndSize(obj15, &buf16, NULL, &alloc16);
	if (!SWIG_IsOK(res16)) {
	SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "new_DoubleInterpolationFunctor" "', argument " "16"" of type '" "char const *""'");
	}
	arg16 = reinterpret_cast< char * >(buf16);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(npstat::DualAxis const &)arg10,arg11,arg12,(npstat::DualAxis const &)arg13,arg14,arg15,(char const *)arg16);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return resultobj;
	fail:
	if (alloc16 == SWIG_NEWOBJ) delete[] buf16;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleInterpolationFunctor__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualAxis *arg1 = 0 ;
	bool arg2 ;
	bool arg3 ;
	npstat::DualAxis *arg4 = 0 ;
	bool arg5 ;
	bool arg6 ;
	npstat::DualAxis *arg7 = 0 ;
	bool arg8 ;
	bool arg9 ;
	npstat::DualAxis *arg10 = 0 ;
	bool arg11 ;
	bool arg12 ;
	npstat::DualAxis *arg13 = 0 ;
	bool arg14 ;
	bool arg15 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	void *argp10 = 0 ;
	int res10 = 0 ;
	bool val11 ;
	int ecode11 = 0 ;
	bool val12 ;
	int ecode12 = 0 ;
	void *argp13 = 0 ;
	int res13 = 0 ;
	bool val14 ;
	int ecode14 = 0 ;
	bool val15 ;
	int ecode15 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	PyObject * obj9 = 0 ;
	PyObject * obj10 = 0 ;
	PyObject * obj11 = 0 ;
	PyObject * obj12 = 0 ;
	PyObject * obj13 = 0 ;
	PyObject * obj14 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOOOOO:new_DoubleInterpolationFunctor",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11,&obj12,&obj13,&obj14)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::DualAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualAxis * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleInterpolationFunctor" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleInterpolationFunctor" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_DoubleInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "4"" of type '" "npstat::DualAxis const &""'");
	}
	arg4 = reinterpret_cast< npstat::DualAxis * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DoubleInterpolationFunctor" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DoubleInterpolationFunctor" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_DoubleInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "7"" of type '" "npstat::DualAxis const &""'");
	}
	arg7 = reinterpret_cast< npstat::DualAxis * >(argp7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_DoubleInterpolationFunctor" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_DoubleInterpolationFunctor" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res10)) {
	SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "new_DoubleInterpolationFunctor" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp10) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "10"" of type '" "npstat::DualAxis const &""'");
	}
	arg10 = reinterpret_cast< npstat::DualAxis * >(argp10);
	ecode11 = SWIG_AsVal_bool(obj10, &val11);
	if (!SWIG_IsOK(ecode11)) {
	SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_DoubleInterpolationFunctor" "', argument " "11"" of type '" "bool""'");
	}
	arg11 = static_cast< bool >(val11);
	ecode12 = SWIG_AsVal_bool(obj11, &val12);
	if (!SWIG_IsOK(ecode12)) {
	SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_DoubleInterpolationFunctor" "', argument " "12"" of type '" "bool""'");
	}
	arg12 = static_cast< bool >(val12);
	res13 = SWIG_ConvertPtr(obj12, &argp13, SWIGTYPE_p_npstat__DualAxis, 0 \| 0);
	if (!SWIG_IsOK(res13)) {
	SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "new_DoubleInterpolationFunctor" "', argument " "13"" of type '" "npstat::DualAxis const &""'");
	}
	if (!argp13) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleInterpolationFunctor" "', argument " "13"" of type '" "npstat::DualAxis const &""'");
	}
	arg13 = reinterpret_cast< npstat::DualAxis * >(argp13);
	ecode14 = SWIG_AsVal_bool(obj13, &val14);
	if (!SWIG_IsOK(ecode14)) {
	SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_DoubleInterpolationFunctor" "', argument " "14"" of type '" "bool""'");
	}
	arg14 = static_cast< bool >(val14);
	ecode15 = SWIG_AsVal_bool(obj14, &val15);
	if (!SWIG_IsOK(ecode15)) {
	SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_DoubleInterpolationFunctor" "', argument " "15"" of type '" "bool""'");
	}
	arg15 = static_cast< bool >(val15);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > )new npstat::StorableInterpolationFunctor< double,npstat::DualAxis >((npstat::DualAxis const &)arg1,arg2,arg3,(npstat::DualAxis const &)arg4,arg5,arg6,(npstat::DualAxis const &)arg7,arg8,arg9,(npstat::DualAxis const &)arg10,arg11,arg12,(npstat::DualAxis const &)arg13,arg14,arg15);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleInterpolationFunctor(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[17] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 16) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleInterpolationFunctor__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleInterpolationFunctor__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__vectorT_std__pairT_bool_bool_t_std__allocatorT_std__pairT_bool_bool_t_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleInterpolationFunctor__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleInterpolationFunctor__SWIG_2(self, args);
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleInterpolationFunctor__SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[6], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleInterpolationFunctor__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 9) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleInterpolationFunctor__SWIG_7(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 10) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[9], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleInterpolationFunctor__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 12) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleInterpolationFunctor__SWIG_9(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 13) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[12], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleInterpolationFunctor__SWIG_8(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 15) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleInterpolationFunctor__SWIG_11(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 16) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[9], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[10], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[11], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[12], 0, SWIGTYPE_p_npstat__DualAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[13], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[14], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[15], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleInterpolationFunctor__SWIG_10(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DoubleInterpolationFunctor'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::StorableInterpolationFunctor(std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::StorableInterpolationFunctor(std::vector< npstat::DualAxis,std::allocator< npstat::DualAxis > > const &,std::vector< std::pair< bool,bool >,std::allocator< std::pair< bool,bool > > > const &)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,char const *)\n"
	" npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::StorableInterpolationFunctor(npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool,npstat::DualAxis const &,bool,bool)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_DoubleInterpolationFunctor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleInterpolationFunctor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleInterpolationFunctor" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::DualAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleInterpolationFunctor_minDim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleInterpolationFunctor_minDim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleInterpolationFunctor_minDim" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableInterpolationFunctor< double,npstat::DualAxis > const *)arg1)->minDim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleInterpolationFunctor___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleInterpolationFunctor___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleInterpolationFunctor___call__" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleInterpolationFunctor___call__" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleInterpolationFunctor___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::StorableInterpolationFunctor< double,npstat::DualAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleInterpolationFunctor_interpolator__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleInterpolationFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleInterpolationFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::Table *) &(arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleInterpolationFunctor_interpolator__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleInterpolationFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleInterpolationFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::Table ) &((npstat::StorableInterpolationFunctor< double,npstat::DualAxis > const )arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleInterpolationFunctor_interpolator(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleInterpolationFunctor_interpolator__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleInterpolationFunctor_interpolator__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleInterpolationFunctor_interpolator'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::interpolator()\n"
	" npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::interpolator() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleInterpolationFunctor_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleInterpolationFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleInterpolationFunctor_table" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleInterpolationFunctor_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleInterpolationFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleInterpolationFunctor_table" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::DualAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > ) &((npstat::StorableInterpolationFunctor< double,npstat::DualAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleInterpolationFunctor_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleInterpolationFunctor_table__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleInterpolationFunctor_table__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleInterpolationFunctor_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::table()\n"
	" npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::table() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleInterpolationFunctor_setConverter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > ) 0 ;
	npstat::Same< double > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleInterpolationFunctor_setConverter",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleInterpolationFunctor_setConverter" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__SameT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleInterpolationFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleInterpolationFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::Same< double > * >(argp2);
	{
	try {
	(arg1)->setConverter((npstat::Same< double > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleInterpolationFunctor_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleInterpolationFunctor_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleInterpolationFunctor_classId" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::DualAxis > * >(argp1);
	{
	try {
	result = ((npstat::StorableInterpolationFunctor< double,npstat::DualAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleInterpolationFunctor_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > arg1 = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleInterpolationFunctor_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleInterpolationFunctor_write" "', argument " "1"" of type '" "npstat::StorableInterpolationFunctor< double,npstat::DualAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableInterpolationFunctor< double,npstat::DualAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleInterpolationFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleInterpolationFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::StorableInterpolationFunctor< double,npstat::DualAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleInterpolationFunctor_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":DoubleInterpolationFunctor_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleInterpolationFunctor_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":DoubleInterpolationFunctor_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleInterpolationFunctor_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableInterpolationFunctor< double,npstat::DualAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleInterpolationFunctor_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleInterpolationFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleInterpolationFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleInterpolationFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleInterpolationFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::StorableInterpolationFunctor< double,npstat::DualAxis > )npstat::StorableInterpolationFunctor< double,npstat::DualAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleInterpolationFunctor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__StorableInterpolationFunctorT_double_npstat__DualAxis_npstat__SameT_double_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_GaussianMixtureEntry__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixtureEntry *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_GaussianMixtureEntry")) SWIG_fail;
	{
	try {
	result = (npstat::GaussianMixtureEntry *)new npstat::GaussianMixtureEntry();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__GaussianMixtureEntry, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_GaussianMixtureEntry__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	double arg3 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::GaussianMixtureEntry *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_GaussianMixtureEntry",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussianMixtureEntry" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GaussianMixtureEntry" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GaussianMixtureEntry" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (npstat::GaussianMixtureEntry *)new npstat::GaussianMixtureEntry(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__GaussianMixtureEntry, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_GaussianMixtureEntry(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 0) {
	return _wrap_new_GaussianMixtureEntry__SWIG_0(self, args);
	}
	if (argc == 3) {
	int _v;
	{
	int res = SWIG_AsVal_double(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_GaussianMixtureEntry__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GaussianMixtureEntry'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::GaussianMixtureEntry::GaussianMixtureEntry()\n"
	" npstat::GaussianMixtureEntry::GaussianMixtureEntry(double const,double const,double const)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntry_weight(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixtureEntry arg1 = (npstat::GaussianMixtureEntry ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntry_weight",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntry_weight" "', argument " "1"" of type '" "npstat::GaussianMixtureEntry const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixtureEntry * >(argp1);
	{
	try {
	result = (double)((npstat::GaussianMixtureEntry const *)arg1)->weight();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntry_mean(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixtureEntry arg1 = (npstat::GaussianMixtureEntry ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntry_mean",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntry_mean" "', argument " "1"" of type '" "npstat::GaussianMixtureEntry const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixtureEntry * >(argp1);
	{
	try {
	result = (double)((npstat::GaussianMixtureEntry const *)arg1)->mean();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntry_stdev(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixtureEntry arg1 = (npstat::GaussianMixtureEntry ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntry_stdev",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntry_stdev" "', argument " "1"" of type '" "npstat::GaussianMixtureEntry const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixtureEntry * >(argp1);
	{
	try {
	result = (double)((npstat::GaussianMixtureEntry const *)arg1)->stdev();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntry___eq__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixtureEntry arg1 = (npstat::GaussianMixtureEntry ) 0 ;
	npstat::GaussianMixtureEntry *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussianMixtureEntry___eq__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntry___eq__" "', argument " "1"" of type '" "npstat::GaussianMixtureEntry const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixtureEntry * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussianMixtureEntry___eq__" "', argument " "2"" of type '" "npstat::GaussianMixtureEntry const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixtureEntry___eq__" "', argument " "2"" of type '" "npstat::GaussianMixtureEntry const &""'");
	}
	arg2 = reinterpret_cast< npstat::GaussianMixtureEntry * >(argp2);
	{
	try {
	result = (bool)((npstat::GaussianMixtureEntry const )arg1)->operator ==((npstat::GaussianMixtureEntry const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntry___ne__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixtureEntry arg1 = (npstat::GaussianMixtureEntry ) 0 ;
	npstat::GaussianMixtureEntry *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussianMixtureEntry___ne__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntry___ne__" "', argument " "1"" of type '" "npstat::GaussianMixtureEntry const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixtureEntry * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussianMixtureEntry___ne__" "', argument " "2"" of type '" "npstat::GaussianMixtureEntry const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixtureEntry___ne__" "', argument " "2"" of type '" "npstat::GaussianMixtureEntry const &""'");
	}
	arg2 = reinterpret_cast< npstat::GaussianMixtureEntry * >(argp2);
	{
	try {
	result = (bool)((npstat::GaussianMixtureEntry const )arg1)->operator !=((npstat::GaussianMixtureEntry const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntry_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixtureEntry arg1 = (npstat::GaussianMixtureEntry ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntry_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntry_classId" "', argument " "1"" of type '" "npstat::GaussianMixtureEntry const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixtureEntry * >(argp1);
	{
	try {
	result = ((npstat::GaussianMixtureEntry const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntry_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixtureEntry arg1 = (npstat::GaussianMixtureEntry ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussianMixtureEntry_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntry_write" "', argument " "1"" of type '" "npstat::GaussianMixtureEntry const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixtureEntry * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussianMixtureEntry_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixtureEntry_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::GaussianMixtureEntry const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntry_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":GaussianMixtureEntry_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::GaussianMixtureEntry::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntry_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":GaussianMixtureEntry_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::GaussianMixtureEntry::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntry_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	npstat::GaussianMixtureEntry arg3 = (npstat::GaussianMixtureEntry ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:GaussianMixtureEntry_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntry_restore" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixtureEntry_restore" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussianMixtureEntry_restore" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixtureEntry_restore" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussianMixtureEntry_restore" "', argument " "3"" of type '" "npstat::GaussianMixtureEntry *""'");
	}
	arg3 = reinterpret_cast< npstat::GaussianMixtureEntry * >(argp3);
	{
	try {
	npstat::GaussianMixtureEntry::restore((gs::ClassId const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_GaussianMixtureEntry(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixtureEntry arg1 = (npstat::GaussianMixtureEntry ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_GaussianMixtureEntry",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixtureEntry, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussianMixtureEntry" "', argument " "1"" of type '" "npstat::GaussianMixtureEntry *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixtureEntry * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject GaussianMixtureEntry_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__GaussianMixtureEntry, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_iterator(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	PyObject arg2 = (PyObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	swig::SwigPyIterator *result = 0 ;

	arg2 = &obj0;
	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntryVector_iterator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_iterator" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	result = (swig::SwigPyIterator *)std_vector_Sl_npstat_GaussianMixtureEntry_Sg__iterator(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___nonzero__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntryVector___nonzero__",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector___nonzero__" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	result = (bool)std_vector_Sl_npstat_GaussianMixtureEntry_Sg____nonzero__((std::vector< npstat::GaussianMixtureEntry > const *)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___bool__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntryVector___bool__",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector___bool__" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	result = (bool)std_vector_Sl_npstat_GaussianMixtureEntry_Sg____bool__((std::vector< npstat::GaussianMixtureEntry > const *)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___len__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::GaussianMixtureEntry >::size_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntryVector___len__",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector___len__" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	result = std_vector_Sl_npstat_GaussianMixtureEntry_Sg____len__((std::vector< npstat::GaussianMixtureEntry > const *)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___getslice__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry >::difference_type arg2 ;
	std::vector< npstat::GaussianMixtureEntry >::difference_type arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:GaussianMixtureEntryVector___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector___getslice__" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussianMixtureEntryVector___getslice__" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::GaussianMixtureEntry >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GaussianMixtureEntryVector___getslice__" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::GaussianMixtureEntry >::difference_type >(val3);
	{
	try {
	try {
	result = (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > *)std_vector_Sl_npstat_GaussianMixtureEntry_Sg____getslice__(arg1,arg2,arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___setslice____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry >::difference_type arg2 ;
	std::vector< npstat::GaussianMixtureEntry >::difference_type arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:GaussianMixtureEntryVector___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector___setslice__" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussianMixtureEntryVector___setslice__" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::GaussianMixtureEntry >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GaussianMixtureEntryVector___setslice__" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::GaussianMixtureEntry >::difference_type >(val3);
	{
	try {
	try {
	std_vector_Sl_npstat_GaussianMixtureEntry_Sg____setslice____SWIG_0(arg1,arg2,arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___setslice____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry >::difference_type arg2 ;
	std::vector< npstat::GaussianMixtureEntry >::difference_type arg3 ;
	std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	int res4 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:GaussianMixtureEntryVector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector___setslice__" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussianMixtureEntryVector___setslice__" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::GaussianMixtureEntry >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GaussianMixtureEntryVector___setslice__" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::GaussianMixtureEntry >::difference_type >(val3);
	{
	std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > ptr = (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > )0;
	res4 = swig::asptr(obj3, &ptr);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GaussianMixtureEntryVector___setslice__" "', argument " "4"" of type '" "std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixtureEntryVector___setslice__" "', argument " "4"" of type '" "std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > const &""'");
	}
	arg4 = ptr;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_GaussianMixtureEntry_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > const &)*arg4);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (SWIG_IsNewObj(res4)) delete arg4;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res4)) delete arg4;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___setslice__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_GaussianMixtureEntryVector___setslice____SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[3], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_GaussianMixtureEntryVector___setslice____SWIG_1(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GaussianMixtureEntryVector___setslice__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::GaussianMixtureEntry >::__setslice__(std::vector< npstat::GaussianMixtureEntry >::difference_type,std::vector< npstat::GaussianMixtureEntry >::difference_type)\n"
	" std::vector< npstat::GaussianMixtureEntry >::__setslice__(std::vector< npstat::GaussianMixtureEntry >::difference_type,std::vector< npstat::GaussianMixtureEntry >::difference_type,std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___delslice__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry >::difference_type arg2 ;
	std::vector< npstat::GaussianMixtureEntry >::difference_type arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:GaussianMixtureEntryVector___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector___delslice__" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussianMixtureEntryVector___delslice__" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::GaussianMixtureEntry >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GaussianMixtureEntryVector___delslice__" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::GaussianMixtureEntry >::difference_type >(val3);
	{
	try {
	try {
	std_vector_Sl_npstat_GaussianMixtureEntry_Sg____delslice__(arg1,arg2,arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___delitem____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry >::difference_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussianMixtureEntryVector___delitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector___delitem__" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussianMixtureEntryVector___delitem__" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::GaussianMixtureEntry >::difference_type >(val2);
	{
	try {
	try {
	std_vector_Sl_npstat_GaussianMixtureEntry_Sg____delitem____SWIG_0(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___getitem____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussianMixtureEntryVector___getitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector___getitem__" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GaussianMixtureEntryVector___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	try {
	try {
	result = (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > *)std_vector_Sl_npstat_GaussianMixtureEntry_Sg____getitem____SWIG_0(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___setitem____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res3 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:GaussianMixtureEntryVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector___setitem__" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GaussianMixtureEntryVector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > ptr = (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > )0;
	res3 = swig::asptr(obj2, &ptr);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussianMixtureEntryVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixtureEntryVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > const &""'");
	}
	arg3 = ptr;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_GaussianMixtureEntry_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > const &)*arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (SWIG_IsNewObj(res3)) delete arg3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res3)) delete arg3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___setitem____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussianMixtureEntryVector___setitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector___setitem__" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GaussianMixtureEntryVector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_GaussianMixtureEntry_Sg____setitem____SWIG_1(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___delitem____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussianMixtureEntryVector___delitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector___delitem__" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GaussianMixtureEntryVector___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_GaussianMixtureEntry_Sg____delitem____SWIG_1(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___delitem__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	return _wrap_GaussianMixtureEntryVector___delitem____SWIG_1(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_GaussianMixtureEntryVector___delitem____SWIG_0(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GaussianMixtureEntryVector___delitem__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::GaussianMixtureEntry >::__delitem__(std::vector< npstat::GaussianMixtureEntry >::difference_type)\n"
	" std::vector< npstat::GaussianMixtureEntry >::__delitem__(PySliceObject *)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___getitem____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry >::difference_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::GaussianMixtureEntry >::value_type *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussianMixtureEntryVector___getitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector___getitem__" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussianMixtureEntryVector___getitem__" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::GaussianMixtureEntry >::difference_type >(val2);
	{
	try {
	try {
	result = (std::vector< npstat::GaussianMixtureEntry >::value_type ) &std_vector_Sl_npstat_GaussianMixtureEntry_Sg____getitem____SWIG_1((std::vector< npstat::GaussianMixtureEntry > const )arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___getitem__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	return _wrap_GaussianMixtureEntryVector___getitem____SWIG_0(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_GaussianMixtureEntryVector___getitem____SWIG_1(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GaussianMixtureEntryVector___getitem__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::GaussianMixtureEntry >::__getitem__(PySliceObject *)\n"
	" std::vector< npstat::GaussianMixtureEntry >::__getitem__(std::vector< npstat::GaussianMixtureEntry >::difference_type) const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___setitem____SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry >::difference_type arg2 ;
	std::vector< npstat::GaussianMixtureEntry >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:GaussianMixtureEntryVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector___setitem__" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussianMixtureEntryVector___setitem__" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::GaussianMixtureEntry >::difference_type >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussianMixtureEntryVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixtureEntryVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry >::value_type * >(argp3);
	{
	try {
	try {
	std_vector_Sl_npstat_GaussianMixtureEntry_Sg____setitem____SWIG_2(arg1,arg2,(npstat::GaussianMixtureEntry const &)*arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector___setitem__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	return _wrap_GaussianMixtureEntryVector___setitem____SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	int res = swig::asptr(argv[2], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_GaussianMixtureEntryVector___setitem____SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__GaussianMixtureEntry, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_GaussianMixtureEntryVector___setitem____SWIG_2(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GaussianMixtureEntryVector___setitem__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::GaussianMixtureEntry >::__setitem__(PySliceObject *,std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > const &)\n"
	" std::vector< npstat::GaussianMixtureEntry >::__setitem__(PySliceObject *)\n"
	" std::vector< npstat::GaussianMixtureEntry >::__setitem__(std::vector< npstat::GaussianMixtureEntry >::difference_type,std::vector< npstat::GaussianMixtureEntry >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_pop(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::GaussianMixtureEntry >::value_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntryVector_pop",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_pop" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	try {
	result = std_vector_Sl_npstat_GaussianMixtureEntry_Sg__pop(arg1);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new std::vector< npstat::GaussianMixtureEntry >::value_type(static_cast< const std::vector< npstat::GaussianMixtureEntry >::value_type& >(result))), SWIGTYPE_p_npstat__GaussianMixtureEntry, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_append(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry >::value_type *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussianMixtureEntryVector_append",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_append" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussianMixtureEntryVector_append" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::value_type const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixtureEntryVector_append" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::value_type const &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry >::value_type * >(argp2);
	{
	try {
	std_vector_Sl_npstat_GaussianMixtureEntry_Sg__append(arg1,(npstat::GaussianMixtureEntry const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_GaussianMixtureEntryVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_GaussianMixtureEntryVector")) SWIG_fail;
	{
	try {
	result = (std::vector< npstat::GaussianMixtureEntry > *)new std::vector< npstat::GaussianMixtureEntry >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_GaussianMixtureEntryVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > *arg1 = 0 ;
	int res1 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::GaussianMixtureEntry > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_GaussianMixtureEntryVector",&obj0)) SWIG_fail;
	{
	std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > ptr = (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianMixtureEntryVector" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianMixtureEntryVector" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > const &""'");
	}
	arg1 = ptr;
	}
	{
	try {
	result = (std::vector< npstat::GaussianMixtureEntry > )new std::vector< npstat::GaussianMixtureEntry >((std::vector< npstat::GaussianMixtureEntry > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_empty(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntryVector_empty",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_empty" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	result = (bool)((std::vector< npstat::GaussianMixtureEntry > const *)arg1)->empty();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_size(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::GaussianMixtureEntry >::size_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntryVector_size",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_size" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	result = ((std::vector< npstat::GaussianMixtureEntry > const *)arg1)->size();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_swap(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussianMixtureEntryVector_swap",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_swap" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussianMixtureEntryVector_swap" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry > &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixtureEntryVector_swap" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry > &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp2);
	{
	try {
	(arg1)->swap(*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_begin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::GaussianMixtureEntry >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntryVector_begin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_begin" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	result = (arg1)->begin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::GaussianMixtureEntry >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_end(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::GaussianMixtureEntry >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntryVector_end",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_end" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	result = (arg1)->end();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::GaussianMixtureEntry >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_rbegin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::GaussianMixtureEntry >::reverse_iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntryVector_rbegin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_rbegin" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	result = (arg1)->rbegin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::GaussianMixtureEntry >::reverse_iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_rend(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::GaussianMixtureEntry >::reverse_iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntryVector_rend",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_rend" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	result = (arg1)->rend();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::GaussianMixtureEntry >::reverse_iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntryVector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_clear" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_get_allocator(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< std::allocator< npstat::GaussianMixtureEntry > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntryVector_get_allocator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_get_allocator" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	result = ((std::vector< npstat::GaussianMixtureEntry > const *)arg1)->get_allocator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new std::vector< npstat::GaussianMixtureEntry >::allocator_type(static_cast< const std::vector< npstat::GaussianMixtureEntry >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_npstat__GaussianMixtureEntry_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_GaussianMixtureEntryVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry >::size_type arg1 ;
	size_t val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::GaussianMixtureEntry > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_GaussianMixtureEntryVector",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_size_t(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussianMixtureEntryVector" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry >::size_type""'");
	}
	arg1 = static_cast< std::vector< npstat::GaussianMixtureEntry >::size_type >(val1);
	{
	try {
	result = (std::vector< npstat::GaussianMixtureEntry > *)new std::vector< npstat::GaussianMixtureEntry >(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_pop_back(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntryVector_pop_back",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_pop_back" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	(arg1)->pop_back();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_resize__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry >::size_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussianMixtureEntryVector_resize",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_resize" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussianMixtureEntryVector_resize" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::GaussianMixtureEntry >::size_type >(val2);
	{
	try {
	(arg1)->resize(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_erase__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry >::iterator arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::GaussianMixtureEntry >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussianMixtureEntryVector_erase",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_erase" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GaussianMixtureEntryVector_erase" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::GaussianMixtureEntry >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::GaussianMixtureEntry >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GaussianMixtureEntryVector_erase" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::iterator""'");
	}
	}
	{
	try {
	result = std_vector_Sl_npstat_GaussianMixtureEntry_Sg__erase__SWIG_0(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::GaussianMixtureEntry >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_erase__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry >::iterator arg2 ;
	std::vector< npstat::GaussianMixtureEntry >::iterator arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	swig::SwigPyIterator *iter3 = 0 ;
	int res3 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	std::vector< npstat::GaussianMixtureEntry >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:GaussianMixtureEntryVector_erase",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_erase" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GaussianMixtureEntryVector_erase" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::GaussianMixtureEntry >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::GaussianMixtureEntry >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GaussianMixtureEntryVector_erase" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::iterator""'");
	}
	}
	res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res3) \|\| !iter3) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GaussianMixtureEntryVector_erase" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::GaussianMixtureEntry >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::GaussianMixtureEntry >::iterator > >(iter3);
	if (iter_t) {
	arg3 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GaussianMixtureEntryVector_erase" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry >::iterator""'");
	}
	}
	{
	try {
	result = std_vector_Sl_npstat_GaussianMixtureEntry_Sg__erase__SWIG_1(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::GaussianMixtureEntry >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_erase(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::GaussianMixtureEntry >::iterator > *>(iter) != 0));
	if (_v) {
	return _wrap_GaussianMixtureEntryVector_erase__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::GaussianMixtureEntry >::iterator > *>(iter) != 0));
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::GaussianMixtureEntry >::iterator > *>(iter) != 0));
	if (_v) {
	return _wrap_GaussianMixtureEntryVector_erase__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GaussianMixtureEntryVector_erase'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::GaussianMixtureEntry >::erase(std::vector< npstat::GaussianMixtureEntry >::iterator)\n"
	" std::vector< npstat::GaussianMixtureEntry >::erase(std::vector< npstat::GaussianMixtureEntry >::iterator,std::vector< npstat::GaussianMixtureEntry >::iterator)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_new_GaussianMixtureEntryVector__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry >::size_type arg1 ;
	std::vector< npstat::GaussianMixtureEntry >::value_type *arg2 = 0 ;
	size_t val1 ;
	int ecode1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::GaussianMixtureEntry > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_GaussianMixtureEntryVector",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_size_t(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussianMixtureEntryVector" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry >::size_type""'");
	}
	arg1 = static_cast< std::vector< npstat::GaussianMixtureEntry >::size_type >(val1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GaussianMixtureEntryVector" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::value_type const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianMixtureEntryVector" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::value_type const &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry >::value_type * >(argp2);
	{
	try {
	result = (std::vector< npstat::GaussianMixtureEntry > )new std::vector< npstat::GaussianMixtureEntry >(arg1,(std::vector< npstat::GaussianMixtureEntry >::value_type const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_GaussianMixtureEntryVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 0) {
	return _wrap_new_GaussianMixtureEntryVector__SWIG_0(self, args);
	}
	if (argc == 1) {
	int _v;
	{
	int res = SWIG_AsVal_size_t(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_GaussianMixtureEntryVector__SWIG_2(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_GaussianMixtureEntryVector__SWIG_1(self, args);
	}
	}
	if (argc == 2) {
	int _v;
	{
	int res = SWIG_AsVal_size_t(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__GaussianMixtureEntry, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_GaussianMixtureEntryVector__SWIG_3(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GaussianMixtureEntryVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::GaussianMixtureEntry >::vector()\n"
	" std::vector< npstat::GaussianMixtureEntry >::vector(std::vector< npstat::GaussianMixtureEntry > const &)\n"
	" std::vector< npstat::GaussianMixtureEntry >::vector(std::vector< npstat::GaussianMixtureEntry >::size_type)\n"
	" std::vector< npstat::GaussianMixtureEntry >::vector(std::vector< npstat::GaussianMixtureEntry >::size_type,std::vector< npstat::GaussianMixtureEntry >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_push_back(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry >::value_type *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussianMixtureEntryVector_push_back",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_push_back" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussianMixtureEntryVector_push_back" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::value_type const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixtureEntryVector_push_back" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::value_type const &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry >::value_type * >(argp2);
	{
	try {
	(arg1)->push_back((std::vector< npstat::GaussianMixtureEntry >::value_type const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_front(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::GaussianMixtureEntry >::value_type *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntryVector_front",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_front" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	result = (std::vector< npstat::GaussianMixtureEntry >::value_type ) &((std::vector< npstat::GaussianMixtureEntry > const )arg1)->front();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_back(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::GaussianMixtureEntry >::value_type *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntryVector_back",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_back" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	result = (std::vector< npstat::GaussianMixtureEntry >::value_type ) &((std::vector< npstat::GaussianMixtureEntry > const )arg1)->back();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_assign(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry >::size_type arg2 ;
	std::vector< npstat::GaussianMixtureEntry >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:GaussianMixtureEntryVector_assign",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_assign" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussianMixtureEntryVector_assign" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::GaussianMixtureEntry >::size_type >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussianMixtureEntryVector_assign" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixtureEntryVector_assign" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry >::value_type * >(argp3);
	{
	try {
	(arg1)->assign(arg2,(std::vector< npstat::GaussianMixtureEntry >::value_type const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_resize__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry >::size_type arg2 ;
	std::vector< npstat::GaussianMixtureEntry >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:GaussianMixtureEntryVector_resize",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_resize" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussianMixtureEntryVector_resize" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::GaussianMixtureEntry >::size_type >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussianMixtureEntryVector_resize" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixtureEntryVector_resize" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry >::value_type * >(argp3);
	{
	try {
	(arg1)->resize(arg2,(std::vector< npstat::GaussianMixtureEntry >::value_type const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_resize(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_size_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_GaussianMixtureEntryVector_resize__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_size_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__GaussianMixtureEntry, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_GaussianMixtureEntryVector_resize__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GaussianMixtureEntryVector_resize'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::GaussianMixtureEntry >::resize(std::vector< npstat::GaussianMixtureEntry >::size_type)\n"
	" std::vector< npstat::GaussianMixtureEntry >::resize(std::vector< npstat::GaussianMixtureEntry >::size_type,std::vector< npstat::GaussianMixtureEntry >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_insert__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry >::iterator arg2 ;
	std::vector< npstat::GaussianMixtureEntry >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	std::vector< npstat::GaussianMixtureEntry >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:GaussianMixtureEntryVector_insert",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_insert" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GaussianMixtureEntryVector_insert" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::GaussianMixtureEntry >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::GaussianMixtureEntry >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GaussianMixtureEntryVector_insert" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::iterator""'");
	}
	}
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussianMixtureEntryVector_insert" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixtureEntryVector_insert" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry >::value_type * >(argp3);
	{
	try {
	result = std_vector_Sl_npstat_GaussianMixtureEntry_Sg__insert__SWIG_0(arg1,arg2,(npstat::GaussianMixtureEntry const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::GaussianMixtureEntry >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_insert__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry >::iterator arg2 ;
	std::vector< npstat::GaussianMixtureEntry >::size_type arg3 ;
	std::vector< npstat::GaussianMixtureEntry >::value_type *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	size_t val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:GaussianMixtureEntryVector_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_insert" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GaussianMixtureEntryVector_insert" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::GaussianMixtureEntry >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::GaussianMixtureEntry >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "GaussianMixtureEntryVector_insert" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::iterator""'");
	}
	}
	ecode3 = SWIG_AsVal_size_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GaussianMixtureEntryVector_insert" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry >::size_type""'");
	}
	arg3 = static_cast< std::vector< npstat::GaussianMixtureEntry >::size_type >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GaussianMixtureEntryVector_insert" "', argument " "4"" of type '" "std::vector< npstat::GaussianMixtureEntry >::value_type const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixtureEntryVector_insert" "', argument " "4"" of type '" "std::vector< npstat::GaussianMixtureEntry >::value_type const &""'");
	}
	arg4 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry >::value_type * >(argp4);
	{
	try {
	std_vector_Sl_npstat_GaussianMixtureEntry_Sg__insert__SWIG_1(arg1,arg2,arg3,(npstat::GaussianMixtureEntry const &)*arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_insert(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::GaussianMixtureEntry >::iterator > *>(iter) != 0));
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__GaussianMixtureEntry, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_GaussianMixtureEntryVector_insert__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::GaussianMixtureEntry >::iterator > *>(iter) != 0));
	if (_v) {
	{
	int res = SWIG_AsVal_size_t(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__GaussianMixtureEntry, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_GaussianMixtureEntryVector_insert__SWIG_1(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GaussianMixtureEntryVector_insert'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::GaussianMixtureEntry >::insert(std::vector< npstat::GaussianMixtureEntry >::iterator,std::vector< npstat::GaussianMixtureEntry >::value_type const &)\n"
	" std::vector< npstat::GaussianMixtureEntry >::insert(std::vector< npstat::GaussianMixtureEntry >::iterator,std::vector< npstat::GaussianMixtureEntry >::size_type,std::vector< npstat::GaussianMixtureEntry >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_reserve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	std::vector< npstat::GaussianMixtureEntry >::size_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussianMixtureEntryVector_reserve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_reserve" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussianMixtureEntryVector_reserve" "', argument " "2"" of type '" "std::vector< npstat::GaussianMixtureEntry >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::GaussianMixtureEntry >::size_type >(val2);
	{
	try {
	(arg1)->reserve(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixtureEntryVector_capacity(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::GaussianMixtureEntry >::size_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixtureEntryVector_capacity",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixtureEntryVector_capacity" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	result = ((std::vector< npstat::GaussianMixtureEntry > const *)arg1)->capacity();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_GaussianMixtureEntryVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::GaussianMixtureEntry > arg1 = (std::vector< npstat::GaussianMixtureEntry > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_GaussianMixtureEntryVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussianMixtureEntryVector" "', argument " "1"" of type '" "std::vector< npstat::GaussianMixtureEntry > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::GaussianMixtureEntry > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject GaussianMixtureEntryVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_npstat__GaussianMixtureEntry_std__allocatorT_npstat__GaussianMixtureEntry_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DiscreteTabulated1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	long arg1 ;
	std::vector< double,std::allocator< double > > *arg2 = 0 ;
	long val1 ;
	int ecode1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::DiscreteTabulated1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_DiscreteTabulated1D",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_long(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DiscreteTabulated1D" "', argument " "1"" of type '" "long""'");
	}
	arg1 = static_cast< long >(val1);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DiscreteTabulated1D" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiscreteTabulated1D" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg2 = ptr;
	}
	{
	try {
	result = (npstat::DiscreteTabulated1D )new npstat::DiscreteTabulated1D(arg1,(std::vector< double,std::allocator< double > > const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DiscreteTabulated1D, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DiscreteTabulated1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DiscreteTabulated1D arg1 = (npstat::DiscreteTabulated1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DiscreteTabulated1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DiscreteTabulated1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscreteTabulated1D" "', argument " "1"" of type '" "npstat::DiscreteTabulated1D *""'");
	}
	arg1 = reinterpret_cast< npstat::DiscreteTabulated1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DiscreteTabulated1D_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DiscreteTabulated1D arg1 = (npstat::DiscreteTabulated1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::DiscreteTabulated1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DiscreteTabulated1D_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DiscreteTabulated1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteTabulated1D_clone" "', argument " "1"" of type '" "npstat::DiscreteTabulated1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DiscreteTabulated1D * >(argp1);
	{
	try {
	result = (npstat::DiscreteTabulated1D )((npstat::DiscreteTabulated1D const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DiscreteTabulated1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DiscreteTabulated1D_probabilities(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DiscreteTabulated1D arg1 = (npstat::DiscreteTabulated1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< double,std::allocator< double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DiscreteTabulated1D_probabilities",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DiscreteTabulated1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteTabulated1D_probabilities" "', argument " "1"" of type '" "npstat::DiscreteTabulated1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DiscreteTabulated1D * >(argp1);
	{
	try {
	result = (std::vector< double,std::allocator< double > > ) &((npstat::DiscreteTabulated1D const )arg1)->probabilities();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DiscreteTabulated1D_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DiscreteTabulated1D arg1 = (npstat::DiscreteTabulated1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:DiscreteTabulated1D_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DiscreteTabulated1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteTabulated1D_classId" "', argument " "1"" of type '" "npstat::DiscreteTabulated1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DiscreteTabulated1D * >(argp1);
	{
	try {
	result = ((npstat::DiscreteTabulated1D const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DiscreteTabulated1D_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DiscreteTabulated1D arg1 = (npstat::DiscreteTabulated1D ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DiscreteTabulated1D_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DiscreteTabulated1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteTabulated1D_write" "', argument " "1"" of type '" "npstat::DiscreteTabulated1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DiscreteTabulated1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteTabulated1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteTabulated1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::DiscreteTabulated1D const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DiscreteTabulated1D_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":DiscreteTabulated1D_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::DiscreteTabulated1D::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DiscreteTabulated1D_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":DiscreteTabulated1D_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::DiscreteTabulated1D::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DiscreteTabulated1D_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::DiscreteTabulated1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DiscreteTabulated1D_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteTabulated1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteTabulated1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteTabulated1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteTabulated1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::DiscreteTabulated1D )npstat::DiscreteTabulated1D::read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DiscreteTabulated1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DiscreteTabulated1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__DiscreteTabulated1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_pooledDiscreteTabulated1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DiscreteTabulated1D *arg1 = 0 ;
	double arg2 ;
	npstat::DiscreteTabulated1D *arg3 = 0 ;
	double arg4 ;
	long arg5 ;
	long arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	long val5 ;
	int ecode5 = 0 ;
	long val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	SwigValueWrapper< npstat::DiscreteTabulated1D > result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:pooledDiscreteTabulated1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DiscreteTabulated1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pooledDiscreteTabulated1D" "', argument " "1"" of type '" "npstat::DiscreteTabulated1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pooledDiscreteTabulated1D" "', argument " "1"" of type '" "npstat::DiscreteTabulated1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::DiscreteTabulated1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pooledDiscreteTabulated1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__DiscreteTabulated1D, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pooledDiscreteTabulated1D" "', argument " "3"" of type '" "npstat::DiscreteTabulated1D const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pooledDiscreteTabulated1D" "', argument " "3"" of type '" "npstat::DiscreteTabulated1D const &""'");
	}
	arg3 = reinterpret_cast< npstat::DiscreteTabulated1D * >(argp3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pooledDiscreteTabulated1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_long(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pooledDiscreteTabulated1D" "', argument " "5"" of type '" "long""'");
	}
	arg5 = static_cast< long >(val5);
	ecode6 = SWIG_AsVal_long(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pooledDiscreteTabulated1D" "', argument " "6"" of type '" "long""'");
	}
	arg6 = static_cast< long >(val6);
	{
	try {
	result = npstat::pooledDiscreteTabulated1D((npstat::DiscreteTabulated1D const &)arg1,arg2,(npstat::DiscreteTabulated1D const &)arg3,arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::DiscreteTabulated1D(static_cast< const npstat::DiscreteTabulated1D& >(result))), SWIGTYPE_p_npstat__DiscreteTabulated1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Poisson1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::Poisson1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_Poisson1D",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Poisson1D" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	{
	try {
	result = (npstat::Poisson1D *)new npstat::Poisson1D(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__Poisson1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Poisson1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Poisson1D *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::Poisson1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_Poisson1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__Poisson1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Poisson1D" "', argument " "1"" of type '" "npstat::Poisson1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Poisson1D" "', argument " "1"" of type '" "npstat::Poisson1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::Poisson1D * >(argp1);
	{
	try {
	result = (npstat::Poisson1D )new npstat::Poisson1D((npstat::Poisson1D const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__Poisson1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Poisson1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__Poisson1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Poisson1D__SWIG_1(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	{
	int res = SWIG_AsVal_double(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Poisson1D__SWIG_0(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Poisson1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::Poisson1D::Poisson1D(double)\n"
	" npstat::Poisson1D::Poisson1D(npstat::Poisson1D const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Poisson1D_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Poisson1D arg1 = (npstat::Poisson1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::Poisson1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:Poisson1D_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Poisson1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poisson1D_clone" "', argument " "1"" of type '" "npstat::Poisson1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::Poisson1D * >(argp1);
	{
	try {
	result = (npstat::Poisson1D )((npstat::Poisson1D const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__Poisson1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Poisson1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Poisson1D arg1 = (npstat::Poisson1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Poisson1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Poisson1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Poisson1D" "', argument " "1"" of type '" "npstat::Poisson1D *""'");
	}
	arg1 = reinterpret_cast< npstat::Poisson1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Poisson1D_mean(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Poisson1D arg1 = (npstat::Poisson1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:Poisson1D_mean",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Poisson1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poisson1D_mean" "', argument " "1"" of type '" "npstat::Poisson1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::Poisson1D * >(argp1);
	{
	try {
	result = (double)((npstat::Poisson1D const *)arg1)->mean();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Poisson1D_probability(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Poisson1D arg1 = (npstat::Poisson1D ) 0 ;
	long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Poisson1D_probability",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Poisson1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poisson1D_probability" "', argument " "1"" of type '" "npstat::Poisson1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::Poisson1D * >(argp1);
	ecode2 = SWIG_AsVal_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Poisson1D_probability" "', argument " "2"" of type '" "long""'");
	}
	arg2 = static_cast< long >(val2);
	{
	try {
	result = (double)((npstat::Poisson1D const *)arg1)->probability(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Poisson1D_cdf(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Poisson1D arg1 = (npstat::Poisson1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Poisson1D_cdf",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Poisson1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poisson1D_cdf" "', argument " "1"" of type '" "npstat::Poisson1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::Poisson1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Poisson1D_cdf" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::Poisson1D const *)arg1)->cdf(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Poisson1D_exceedance(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Poisson1D arg1 = (npstat::Poisson1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Poisson1D_exceedance",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Poisson1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poisson1D_exceedance" "', argument " "1"" of type '" "npstat::Poisson1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::Poisson1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Poisson1D_exceedance" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::Poisson1D const *)arg1)->exceedance(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Poisson1D_quantile(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Poisson1D arg1 = (npstat::Poisson1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	long result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Poisson1D_quantile",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Poisson1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poisson1D_quantile" "', argument " "1"" of type '" "npstat::Poisson1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::Poisson1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Poisson1D_quantile" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (long)((npstat::Poisson1D const *)arg1)->quantile(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_long(static_cast< long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Poisson1D_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Poisson1D arg1 = (npstat::Poisson1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:Poisson1D_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Poisson1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poisson1D_classId" "', argument " "1"" of type '" "npstat::Poisson1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::Poisson1D * >(argp1);
	{
	try {
	result = ((npstat::Poisson1D const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Poisson1D_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Poisson1D arg1 = (npstat::Poisson1D ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Poisson1D_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Poisson1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poisson1D_write" "', argument " "1"" of type '" "npstat::Poisson1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::Poisson1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Poisson1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Poisson1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::Poisson1D const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Poisson1D_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":Poisson1D_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::Poisson1D::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Poisson1D_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":Poisson1D_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::Poisson1D::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Poisson1D_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::Poisson1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Poisson1D_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poisson1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Poisson1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Poisson1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Poisson1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::Poisson1D )npstat::Poisson1D::read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__Poisson1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Poisson1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__Poisson1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveRecord_DiscreteTabulated1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DiscreteTabulated1D *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveRecord< npstat::DiscreteTabulated1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveRecord_DiscreteTabulated1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DiscreteTabulated1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveRecord_DiscreteTabulated1D" "', argument " "1"" of type '" "npstat::DiscreteTabulated1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveRecord_DiscreteTabulated1D" "', argument " "1"" of type '" "npstat::DiscreteTabulated1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::DiscreteTabulated1D * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveRecord_DiscreteTabulated1D" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveRecord_DiscreteTabulated1D" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveRecord< npstat::DiscreteTabulated1D > )new gs::ArchiveRecord< npstat::DiscreteTabulated1D >((npstat::DiscreteTabulated1D const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveRecordT_npstat__DiscreteTabulated1D_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveRecord_DiscreteTabulated1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveRecord< npstat::DiscreteTabulated1D > arg1 = (gs::ArchiveRecord< npstat::DiscreteTabulated1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveRecord_DiscreteTabulated1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveRecordT_npstat__DiscreteTabulated1D_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveRecord_DiscreteTabulated1D" "', argument " "1"" of type '" "gs::ArchiveRecord< npstat::DiscreteTabulated1D > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveRecord< npstat::DiscreteTabulated1D > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveRecord_DiscreteTabulated1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveRecordT_npstat__DiscreteTabulated1D_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPRecord__SWIG_71(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DiscreteTabulated1D *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveRecord< npstat::DiscreteTabulated1D > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPRecord",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DiscreteTabulated1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::DiscreteTabulated1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::DiscreteTabulated1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::DiscreteTabulated1D * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPRecord" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPRecord" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR Record< npstat::DiscreteTabulated1D >((npstat::DiscreteTabulated1D const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveRecord< npstat::DiscreteTabulated1D >(static_cast< const gs::ArchiveRecord< npstat::DiscreteTabulated1D >& >(result))), SWIGTYPE_p_gs__ArchiveRecordT_npstat__DiscreteTabulated1D_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DiscreteTabulated1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< npstat::DiscreteTabulated1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_DiscreteTabulated1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DiscreteTabulated1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DiscreteTabulated1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_DiscreteTabulated1D" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< npstat::DiscreteTabulated1D > )new gs::Reference< npstat::DiscreteTabulated1D >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__DiscreteTabulated1D_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DiscreteTabulated1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::DiscreteTabulated1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_DiscreteTabulated1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DiscreteTabulated1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DiscreteTabulated1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_DiscreteTabulated1D" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_DiscreteTabulated1D" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< npstat::DiscreteTabulated1D > )new gs::Reference< npstat::DiscreteTabulated1D >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__DiscreteTabulated1D_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DiscreteTabulated1D__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::DiscreteTabulated1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_DiscreteTabulated1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DiscreteTabulated1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DiscreteTabulated1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_DiscreteTabulated1D" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DiscreteTabulated1D" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_DiscreteTabulated1D" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DiscreteTabulated1D" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< npstat::DiscreteTabulated1D > )new gs::Reference< npstat::DiscreteTabulated1D >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__DiscreteTabulated1D_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DiscreteTabulated1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_DiscreteTabulated1D__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_DiscreteTabulated1D__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_DiscreteTabulated1D__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_DiscreteTabulated1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< npstat::DiscreteTabulated1D >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< npstat::DiscreteTabulated1D >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< npstat::DiscreteTabulated1D >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_DiscreteTabulated1D_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::DiscreteTabulated1D > arg1 = (gs::Reference< npstat::DiscreteTabulated1D > ) 0 ;
	unsigned long arg2 ;
	npstat::DiscreteTabulated1D arg3 = (npstat::DiscreteTabulated1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_DiscreteTabulated1D_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__DiscreteTabulated1D_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_DiscreteTabulated1D_restore" "', argument " "1"" of type '" "gs::Reference< npstat::DiscreteTabulated1D > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::DiscreteTabulated1D > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_DiscreteTabulated1D_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__DiscreteTabulated1D, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_DiscreteTabulated1D_restore" "', argument " "3"" of type '" "npstat::DiscreteTabulated1D *""'");
	}
	arg3 = reinterpret_cast< npstat::DiscreteTabulated1D * >(argp3);
	{
	try {
	((gs::Reference< npstat::DiscreteTabulated1D > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_DiscreteTabulated1D_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::DiscreteTabulated1D > arg1 = (gs::Reference< npstat::DiscreteTabulated1D > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::DiscreteTabulated1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_DiscreteTabulated1D_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__DiscreteTabulated1D_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_DiscreteTabulated1D_retrieve" "', argument " "1"" of type '" "gs::Reference< npstat::DiscreteTabulated1D > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::DiscreteTabulated1D > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_DiscreteTabulated1D_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (npstat::DiscreteTabulated1D )gs_Reference_Sl_npstat_DiscreteTabulated1D_Sg__retrieve((gs::Reference< npstat::DiscreteTabulated1D > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DiscreteTabulated1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_DiscreteTabulated1D_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::DiscreteTabulated1D > arg1 = (gs::Reference< npstat::DiscreteTabulated1D > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	SwigValueWrapper< npstat::DiscreteTabulated1D > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_DiscreteTabulated1D_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__DiscreteTabulated1D_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_DiscreteTabulated1D_getValue" "', argument " "1"" of type '" "gs::Reference< npstat::DiscreteTabulated1D > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::DiscreteTabulated1D > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_DiscreteTabulated1D_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_npstat_DiscreteTabulated1D_Sg__getValue((gs::Reference< npstat::DiscreteTabulated1D > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::DiscreteTabulated1D(static_cast< const npstat::DiscreteTabulated1D& >(result))), SWIGTYPE_p_npstat__DiscreteTabulated1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_DiscreteTabulated1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::DiscreteTabulated1D > arg1 = (gs::Reference< npstat::DiscreteTabulated1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_DiscreteTabulated1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__DiscreteTabulated1D_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_DiscreteTabulated1D" "', argument " "1"" of type '" "gs::Reference< npstat::DiscreteTabulated1D > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::DiscreteTabulated1D > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_DiscreteTabulated1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_npstat__DiscreteTabulated1D_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveRecord_Poisson1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Poisson1D *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveRecord< npstat::Poisson1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveRecord_Poisson1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__Poisson1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveRecord_Poisson1D" "', argument " "1"" of type '" "npstat::Poisson1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveRecord_Poisson1D" "', argument " "1"" of type '" "npstat::Poisson1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::Poisson1D * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveRecord_Poisson1D" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveRecord_Poisson1D" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveRecord< npstat::Poisson1D > )new gs::ArchiveRecord< npstat::Poisson1D >((npstat::Poisson1D const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveRecordT_npstat__Poisson1D_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveRecord_Poisson1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveRecord< npstat::Poisson1D > arg1 = (gs::ArchiveRecord< npstat::Poisson1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveRecord_Poisson1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveRecordT_npstat__Poisson1D_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveRecord_Poisson1D" "', argument " "1"" of type '" "gs::ArchiveRecord< npstat::Poisson1D > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveRecord< npstat::Poisson1D > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveRecord_Poisson1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveRecordT_npstat__Poisson1D_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPRecord__SWIG_72(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Poisson1D *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveRecord< npstat::Poisson1D > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPRecord",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__Poisson1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::Poisson1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::Poisson1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::Poisson1D * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPRecord" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPRecord" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR Record< npstat::Poisson1D >((npstat::Poisson1D const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveRecord< npstat::Poisson1D >(static_cast< const gs::ArchiveRecord< npstat::Poisson1D >& >(result))), SWIGTYPE_p_gs__ArchiveRecordT_npstat__Poisson1D_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Poisson1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< npstat::Poisson1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_Poisson1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Poisson1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Poisson1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_Poisson1D" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< npstat::Poisson1D > )new gs::Reference< npstat::Poisson1D >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__Poisson1D_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Poisson1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::Poisson1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_Poisson1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Poisson1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Poisson1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_Poisson1D" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_Poisson1D" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< npstat::Poisson1D > )new gs::Reference< npstat::Poisson1D >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__Poisson1D_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Poisson1D__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::Poisson1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_Poisson1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Poisson1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Poisson1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_Poisson1D" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Poisson1D" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_Poisson1D" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Poisson1D" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< npstat::Poisson1D > )new gs::Reference< npstat::Poisson1D >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__Poisson1D_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Poisson1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_Poisson1D__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_Poisson1D__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_Poisson1D__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_Poisson1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< npstat::Poisson1D >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< npstat::Poisson1D >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< npstat::Poisson1D >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_Poisson1D_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::Poisson1D > arg1 = (gs::Reference< npstat::Poisson1D > ) 0 ;
	unsigned long arg2 ;
	npstat::Poisson1D arg3 = (npstat::Poisson1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_Poisson1D_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__Poisson1D_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Poisson1D_restore" "', argument " "1"" of type '" "gs::Reference< npstat::Poisson1D > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::Poisson1D > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Poisson1D_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__Poisson1D, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_Poisson1D_restore" "', argument " "3"" of type '" "npstat::Poisson1D *""'");
	}
	arg3 = reinterpret_cast< npstat::Poisson1D * >(argp3);
	{
	try {
	((gs::Reference< npstat::Poisson1D > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_Poisson1D_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::Poisson1D > arg1 = (gs::Reference< npstat::Poisson1D > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::Poisson1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_Poisson1D_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__Poisson1D_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Poisson1D_retrieve" "', argument " "1"" of type '" "gs::Reference< npstat::Poisson1D > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::Poisson1D > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Poisson1D_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (npstat::Poisson1D )gs_Reference_Sl_npstat_Poisson1D_Sg__retrieve((gs::Reference< npstat::Poisson1D > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__Poisson1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_Poisson1D_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::Poisson1D > arg1 = (gs::Reference< npstat::Poisson1D > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	SwigValueWrapper< npstat::Poisson1D > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_Poisson1D_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__Poisson1D_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Poisson1D_getValue" "', argument " "1"" of type '" "gs::Reference< npstat::Poisson1D > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::Poisson1D > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Poisson1D_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_npstat_Poisson1D_Sg__getValue((gs::Reference< npstat::Poisson1D > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::Poisson1D(static_cast< const npstat::Poisson1D& >(result))), SWIGTYPE_p_npstat__Poisson1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_Poisson1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::Poisson1D > arg1 = (gs::Reference< npstat::Poisson1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_Poisson1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__Poisson1D_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_Poisson1D" "', argument " "1"" of type '" "gs::Reference< npstat::Poisson1D > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::Poisson1D > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_Poisson1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_npstat__Poisson1D_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_LogMapper1d__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LogMapper1d *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_LogMapper1d")) SWIG_fail;
	{
	try {
	result = (npstat::LogMapper1d *)new npstat::LogMapper1d();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LogMapper1d, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LogMapper1d__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::LogMapper1d *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_LogMapper1d",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LogMapper1d" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LogMapper1d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LogMapper1d" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LogMapper1d" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	result = (npstat::LogMapper1d *)new npstat::LogMapper1d(arg1,arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LogMapper1d, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LogMapper1d__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LogMapper1d *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_LogMapper1d",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LogMapper1d" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LogMapper1d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (npstat::LogMapper1d *)new npstat::LogMapper1d(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LogMapper1d, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LogMapper1d(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 0) {
	return _wrap_new_LogMapper1d__SWIG_0(self, args);
	}
	if (argc == 2) {
	int _v;
	{
	int res = SWIG_AsVal_double(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_LogMapper1d__SWIG_2(self, args);
	}
	}
	}
	if (argc == 4) {
	int _v;
	{
	int res = SWIG_AsVal_double(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_LogMapper1d__SWIG_1(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LogMapper1d'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LogMapper1d::LogMapper1d()\n"
	" npstat::LogMapper1d::LogMapper1d(double const,double const,double const,double const)\n"
	" npstat::LogMapper1d::LogMapper1d(double const,double const)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_LogMapper1d___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LogMapper1d arg1 = (npstat::LogMapper1d ) 0 ;
	double *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:LogMapper1d___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LogMapper1d, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1d___call__" "', argument " "1"" of type '" "npstat::LogMapper1d const *""'");
	}
	arg1 = reinterpret_cast< npstat::LogMapper1d * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogMapper1d___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	{
	try {
	result = (double)((npstat::LogMapper1d const )arg1)->operator ()((double const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1d_a(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LogMapper1d arg1 = (npstat::LogMapper1d ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1d_a",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LogMapper1d, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1d_a" "', argument " "1"" of type '" "npstat::LogMapper1d const *""'");
	}
	arg1 = reinterpret_cast< npstat::LogMapper1d * >(argp1);
	{
	try {
	result = (double)((npstat::LogMapper1d const *)arg1)->a();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1d_b(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LogMapper1d arg1 = (npstat::LogMapper1d ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1d_b",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LogMapper1d, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1d_b" "', argument " "1"" of type '" "npstat::LogMapper1d const *""'");
	}
	arg1 = reinterpret_cast< npstat::LogMapper1d * >(argp1);
	{
	try {
	result = (double)((npstat::LogMapper1d const *)arg1)->b();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_LogMapper1d(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LogMapper1d arg1 = (npstat::LogMapper1d ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LogMapper1d",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LogMapper1d, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogMapper1d" "', argument " "1"" of type '" "npstat::LogMapper1d *""'");
	}
	arg1 = reinterpret_cast< npstat::LogMapper1d * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject LogMapper1d_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__LogMapper1d, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_LogMapper1dVector_iterator(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	PyObject arg2 = (PyObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	swig::SwigPyIterator *result = 0 ;

	arg2 = &obj0;
	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1dVector_iterator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_iterator" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	result = (swig::SwigPyIterator *)std_vector_Sl_npstat_LogMapper1d_Sg__iterator(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___nonzero__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1dVector___nonzero__",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector___nonzero__" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	result = (bool)std_vector_Sl_npstat_LogMapper1d_Sg____nonzero__((std::vector< npstat::LogMapper1d > const *)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___bool__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1dVector___bool__",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector___bool__" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	result = (bool)std_vector_Sl_npstat_LogMapper1d_Sg____bool__((std::vector< npstat::LogMapper1d > const *)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___len__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LogMapper1d >::size_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1dVector___len__",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector___len__" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	result = std_vector_Sl_npstat_LogMapper1d_Sg____len__((std::vector< npstat::LogMapper1d > const *)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___getslice__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d >::difference_type arg2 ;
	std::vector< npstat::LogMapper1d >::difference_type arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LogMapper1dVector___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector___getslice__" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogMapper1dVector___getslice__" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LogMapper1d >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogMapper1dVector___getslice__" "', argument " "3"" of type '" "std::vector< npstat::LogMapper1d >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::LogMapper1d >::difference_type >(val3);
	{
	try {
	try {
	result = (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > *)std_vector_Sl_npstat_LogMapper1d_Sg____getslice__(arg1,arg2,arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___setslice____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d >::difference_type arg2 ;
	std::vector< npstat::LogMapper1d >::difference_type arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LogMapper1dVector___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector___setslice__" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogMapper1dVector___setslice__" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LogMapper1d >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogMapper1dVector___setslice__" "', argument " "3"" of type '" "std::vector< npstat::LogMapper1d >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::LogMapper1d >::difference_type >(val3);
	{
	try {
	try {
	std_vector_Sl_npstat_LogMapper1d_Sg____setslice____SWIG_0(arg1,arg2,arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___setslice____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d >::difference_type arg2 ;
	std::vector< npstat::LogMapper1d >::difference_type arg3 ;
	std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	int res4 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:LogMapper1dVector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector___setslice__" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogMapper1dVector___setslice__" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LogMapper1d >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogMapper1dVector___setslice__" "', argument " "3"" of type '" "std::vector< npstat::LogMapper1d >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::LogMapper1d >::difference_type >(val3);
	{
	std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > ptr = (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > )0;
	res4 = swig::asptr(obj3, &ptr);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LogMapper1dVector___setslice__" "', argument " "4"" of type '" "std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogMapper1dVector___setslice__" "', argument " "4"" of type '" "std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > const &""'");
	}
	arg4 = ptr;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_LogMapper1d_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > const &)*arg4);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (SWIG_IsNewObj(res4)) delete arg4;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res4)) delete arg4;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___setslice__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_LogMapper1dVector___setslice____SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[3], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_LogMapper1dVector___setslice____SWIG_1(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LogMapper1dVector___setslice__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::LogMapper1d >::__setslice__(std::vector< npstat::LogMapper1d >::difference_type,std::vector< npstat::LogMapper1d >::difference_type)\n"
	" std::vector< npstat::LogMapper1d >::__setslice__(std::vector< npstat::LogMapper1d >::difference_type,std::vector< npstat::LogMapper1d >::difference_type,std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___delslice__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d >::difference_type arg2 ;
	std::vector< npstat::LogMapper1d >::difference_type arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LogMapper1dVector___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector___delslice__" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogMapper1dVector___delslice__" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LogMapper1d >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogMapper1dVector___delslice__" "', argument " "3"" of type '" "std::vector< npstat::LogMapper1d >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::LogMapper1d >::difference_type >(val3);
	{
	try {
	try {
	std_vector_Sl_npstat_LogMapper1d_Sg____delslice__(arg1,arg2,arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___delitem____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d >::difference_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LogMapper1dVector___delitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector___delitem__" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogMapper1dVector___delitem__" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LogMapper1d >::difference_type >(val2);
	{
	try {
	try {
	std_vector_Sl_npstat_LogMapper1d_Sg____delitem____SWIG_0(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___getitem____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LogMapper1dVector___getitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector___getitem__" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LogMapper1dVector___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	try {
	try {
	result = (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > *)std_vector_Sl_npstat_LogMapper1d_Sg____getitem____SWIG_0(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___setitem____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res3 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LogMapper1dVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector___setitem__" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LogMapper1dVector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > ptr = (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > )0;
	res3 = swig::asptr(obj2, &ptr);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LogMapper1dVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogMapper1dVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > const &""'");
	}
	arg3 = ptr;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_LogMapper1d_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > const &)*arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (SWIG_IsNewObj(res3)) delete arg3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res3)) delete arg3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___setitem____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LogMapper1dVector___setitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector___setitem__" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LogMapper1dVector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_LogMapper1d_Sg____setitem____SWIG_1(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___delitem____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LogMapper1dVector___delitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector___delitem__" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LogMapper1dVector___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_LogMapper1d_Sg____delitem____SWIG_1(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___delitem__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	return _wrap_LogMapper1dVector___delitem____SWIG_1(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_LogMapper1dVector___delitem____SWIG_0(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LogMapper1dVector___delitem__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::LogMapper1d >::__delitem__(std::vector< npstat::LogMapper1d >::difference_type)\n"
	" std::vector< npstat::LogMapper1d >::__delitem__(PySliceObject *)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___getitem____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d >::difference_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::LogMapper1d >::value_type *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LogMapper1dVector___getitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector___getitem__" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogMapper1dVector___getitem__" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LogMapper1d >::difference_type >(val2);
	{
	try {
	try {
	result = (std::vector< npstat::LogMapper1d >::value_type ) &std_vector_Sl_npstat_LogMapper1d_Sg____getitem____SWIG_1((std::vector< npstat::LogMapper1d > const )arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LogMapper1d, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___getitem__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	return _wrap_LogMapper1dVector___getitem____SWIG_0(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_LogMapper1dVector___getitem____SWIG_1(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LogMapper1dVector___getitem__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::LogMapper1d >::__getitem__(PySliceObject *)\n"
	" std::vector< npstat::LogMapper1d >::__getitem__(std::vector< npstat::LogMapper1d >::difference_type) const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___setitem____SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d >::difference_type arg2 ;
	std::vector< npstat::LogMapper1d >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LogMapper1dVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector___setitem__" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogMapper1dVector___setitem__" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LogMapper1d >::difference_type >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__LogMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LogMapper1dVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::LogMapper1d >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogMapper1dVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::LogMapper1d >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::LogMapper1d >::value_type * >(argp3);
	{
	try {
	try {
	std_vector_Sl_npstat_LogMapper1d_Sg____setitem____SWIG_2(arg1,arg2,(npstat::LogMapper1d const &)*arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector___setitem__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	return _wrap_LogMapper1dVector___setitem____SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	int res = swig::asptr(argv[2], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_LogMapper1dVector___setitem____SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__LogMapper1d, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_LogMapper1dVector___setitem____SWIG_2(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LogMapper1dVector___setitem__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::LogMapper1d >::__setitem__(PySliceObject *,std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > const &)\n"
	" std::vector< npstat::LogMapper1d >::__setitem__(PySliceObject *)\n"
	" std::vector< npstat::LogMapper1d >::__setitem__(std::vector< npstat::LogMapper1d >::difference_type,std::vector< npstat::LogMapper1d >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_pop(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LogMapper1d >::value_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1dVector_pop",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_pop" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	try {
	result = std_vector_Sl_npstat_LogMapper1d_Sg__pop(arg1);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new std::vector< npstat::LogMapper1d >::value_type(static_cast< const std::vector< npstat::LogMapper1d >::value_type& >(result))), SWIGTYPE_p_npstat__LogMapper1d, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_append(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d >::value_type *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LogMapper1dVector_append",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_append" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LogMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogMapper1dVector_append" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::value_type const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogMapper1dVector_append" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::value_type const &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::LogMapper1d >::value_type * >(argp2);
	{
	try {
	std_vector_Sl_npstat_LogMapper1d_Sg__append(arg1,(npstat::LogMapper1d const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LogMapper1dVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_LogMapper1dVector")) SWIG_fail;
	{
	try {
	result = (std::vector< npstat::LogMapper1d > *)new std::vector< npstat::LogMapper1d >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LogMapper1dVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > *arg1 = 0 ;
	int res1 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LogMapper1d > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_LogMapper1dVector",&obj0)) SWIG_fail;
	{
	std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > ptr = (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LogMapper1dVector" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogMapper1dVector" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > const &""'");
	}
	arg1 = ptr;
	}
	{
	try {
	result = (std::vector< npstat::LogMapper1d > )new std::vector< npstat::LogMapper1d >((std::vector< npstat::LogMapper1d > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_empty(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1dVector_empty",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_empty" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	result = (bool)((std::vector< npstat::LogMapper1d > const *)arg1)->empty();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_size(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LogMapper1d >::size_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1dVector_size",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_size" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	result = ((std::vector< npstat::LogMapper1d > const *)arg1)->size();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_swap(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LogMapper1dVector_swap",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_swap" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogMapper1dVector_swap" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d > &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogMapper1dVector_swap" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d > &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp2);
	{
	try {
	(arg1)->swap(*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_begin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LogMapper1d >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1dVector_begin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_begin" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	result = (arg1)->begin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::LogMapper1d >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_end(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LogMapper1d >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1dVector_end",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_end" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	result = (arg1)->end();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::LogMapper1d >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_rbegin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LogMapper1d >::reverse_iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1dVector_rbegin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_rbegin" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	result = (arg1)->rbegin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::LogMapper1d >::reverse_iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_rend(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LogMapper1d >::reverse_iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1dVector_rend",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_rend" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	result = (arg1)->rend();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::LogMapper1d >::reverse_iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1dVector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_clear" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_get_allocator(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< std::allocator< npstat::LogMapper1d > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1dVector_get_allocator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_get_allocator" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	result = ((std::vector< npstat::LogMapper1d > const *)arg1)->get_allocator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new std::vector< npstat::LogMapper1d >::allocator_type(static_cast< const std::vector< npstat::LogMapper1d >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_npstat__LogMapper1d_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LogMapper1dVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d >::size_type arg1 ;
	size_t val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LogMapper1d > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_LogMapper1dVector",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_size_t(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LogMapper1dVector" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d >::size_type""'");
	}
	arg1 = static_cast< std::vector< npstat::LogMapper1d >::size_type >(val1);
	{
	try {
	result = (std::vector< npstat::LogMapper1d > *)new std::vector< npstat::LogMapper1d >(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_pop_back(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1dVector_pop_back",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_pop_back" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	(arg1)->pop_back();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_resize__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d >::size_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LogMapper1dVector_resize",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_resize" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogMapper1dVector_resize" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LogMapper1d >::size_type >(val2);
	{
	try {
	(arg1)->resize(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_erase__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d >::iterator arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::LogMapper1d >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"OO:LogMapper1dVector_erase",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_erase" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LogMapper1dVector_erase" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::LogMapper1d >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LogMapper1d >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LogMapper1dVector_erase" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::iterator""'");
	}
	}
	{
	try {
	result = std_vector_Sl_npstat_LogMapper1d_Sg__erase__SWIG_0(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::LogMapper1d >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_erase__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d >::iterator arg2 ;
	std::vector< npstat::LogMapper1d >::iterator arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	swig::SwigPyIterator *iter3 = 0 ;
	int res3 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	std::vector< npstat::LogMapper1d >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LogMapper1dVector_erase",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_erase" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LogMapper1dVector_erase" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::LogMapper1d >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LogMapper1d >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LogMapper1dVector_erase" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::iterator""'");
	}
	}
	res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res3) \|\| !iter3) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LogMapper1dVector_erase" "', argument " "3"" of type '" "std::vector< npstat::LogMapper1d >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::LogMapper1d >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LogMapper1d >::iterator > >(iter3);
	if (iter_t) {
	arg3 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LogMapper1dVector_erase" "', argument " "3"" of type '" "std::vector< npstat::LogMapper1d >::iterator""'");
	}
	}
	{
	try {
	result = std_vector_Sl_npstat_LogMapper1d_Sg__erase__SWIG_1(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::LogMapper1d >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_erase(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LogMapper1d >::iterator > *>(iter) != 0));
	if (_v) {
	return _wrap_LogMapper1dVector_erase__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LogMapper1d >::iterator > *>(iter) != 0));
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LogMapper1d >::iterator > *>(iter) != 0));
	if (_v) {
	return _wrap_LogMapper1dVector_erase__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LogMapper1dVector_erase'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::LogMapper1d >::erase(std::vector< npstat::LogMapper1d >::iterator)\n"
	" std::vector< npstat::LogMapper1d >::erase(std::vector< npstat::LogMapper1d >::iterator,std::vector< npstat::LogMapper1d >::iterator)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_new_LogMapper1dVector__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d >::size_type arg1 ;
	std::vector< npstat::LogMapper1d >::value_type *arg2 = 0 ;
	size_t val1 ;
	int ecode1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::LogMapper1d > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_LogMapper1dVector",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_size_t(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LogMapper1dVector" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d >::size_type""'");
	}
	arg1 = static_cast< std::vector< npstat::LogMapper1d >::size_type >(val1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LogMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LogMapper1dVector" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::value_type const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LogMapper1dVector" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::value_type const &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::LogMapper1d >::value_type * >(argp2);
	{
	try {
	result = (std::vector< npstat::LogMapper1d > )new std::vector< npstat::LogMapper1d >(arg1,(std::vector< npstat::LogMapper1d >::value_type const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LogMapper1dVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 0) {
	return _wrap_new_LogMapper1dVector__SWIG_0(self, args);
	}
	if (argc == 1) {
	int _v;
	{
	int res = SWIG_AsVal_size_t(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_LogMapper1dVector__SWIG_2(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_LogMapper1dVector__SWIG_1(self, args);
	}
	}
	if (argc == 2) {
	int _v;
	{
	int res = SWIG_AsVal_size_t(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__LogMapper1d, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_LogMapper1dVector__SWIG_3(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LogMapper1dVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::LogMapper1d >::vector()\n"
	" std::vector< npstat::LogMapper1d >::vector(std::vector< npstat::LogMapper1d > const &)\n"
	" std::vector< npstat::LogMapper1d >::vector(std::vector< npstat::LogMapper1d >::size_type)\n"
	" std::vector< npstat::LogMapper1d >::vector(std::vector< npstat::LogMapper1d >::size_type,std::vector< npstat::LogMapper1d >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_push_back(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d >::value_type *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LogMapper1dVector_push_back",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_push_back" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LogMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LogMapper1dVector_push_back" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::value_type const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogMapper1dVector_push_back" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::value_type const &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::LogMapper1d >::value_type * >(argp2);
	{
	try {
	(arg1)->push_back((std::vector< npstat::LogMapper1d >::value_type const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_front(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LogMapper1d >::value_type *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1dVector_front",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_front" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	result = (std::vector< npstat::LogMapper1d >::value_type ) &((std::vector< npstat::LogMapper1d > const )arg1)->front();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LogMapper1d, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_back(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LogMapper1d >::value_type *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1dVector_back",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_back" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	result = (std::vector< npstat::LogMapper1d >::value_type ) &((std::vector< npstat::LogMapper1d > const )arg1)->back();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LogMapper1d, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_assign(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d >::size_type arg2 ;
	std::vector< npstat::LogMapper1d >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LogMapper1dVector_assign",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_assign" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogMapper1dVector_assign" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LogMapper1d >::size_type >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__LogMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LogMapper1dVector_assign" "', argument " "3"" of type '" "std::vector< npstat::LogMapper1d >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogMapper1dVector_assign" "', argument " "3"" of type '" "std::vector< npstat::LogMapper1d >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::LogMapper1d >::value_type * >(argp3);
	{
	try {
	(arg1)->assign(arg2,(std::vector< npstat::LogMapper1d >::value_type const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_resize__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d >::size_type arg2 ;
	std::vector< npstat::LogMapper1d >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LogMapper1dVector_resize",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_resize" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogMapper1dVector_resize" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LogMapper1d >::size_type >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__LogMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LogMapper1dVector_resize" "', argument " "3"" of type '" "std::vector< npstat::LogMapper1d >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogMapper1dVector_resize" "', argument " "3"" of type '" "std::vector< npstat::LogMapper1d >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::LogMapper1d >::value_type * >(argp3);
	{
	try {
	(arg1)->resize(arg2,(std::vector< npstat::LogMapper1d >::value_type const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_resize(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_size_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_LogMapper1dVector_resize__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_size_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__LogMapper1d, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_LogMapper1dVector_resize__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LogMapper1dVector_resize'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::LogMapper1d >::resize(std::vector< npstat::LogMapper1d >::size_type)\n"
	" std::vector< npstat::LogMapper1d >::resize(std::vector< npstat::LogMapper1d >::size_type,std::vector< npstat::LogMapper1d >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_insert__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d >::iterator arg2 ;
	std::vector< npstat::LogMapper1d >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	std::vector< npstat::LogMapper1d >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LogMapper1dVector_insert",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_insert" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LogMapper1dVector_insert" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::LogMapper1d >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LogMapper1d >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LogMapper1dVector_insert" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::iterator""'");
	}
	}
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__LogMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LogMapper1dVector_insert" "', argument " "3"" of type '" "std::vector< npstat::LogMapper1d >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogMapper1dVector_insert" "', argument " "3"" of type '" "std::vector< npstat::LogMapper1d >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::LogMapper1d >::value_type * >(argp3);
	{
	try {
	result = std_vector_Sl_npstat_LogMapper1d_Sg__insert__SWIG_0(arg1,arg2,(npstat::LogMapper1d const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::LogMapper1d >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_insert__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d >::iterator arg2 ;
	std::vector< npstat::LogMapper1d >::size_type arg3 ;
	std::vector< npstat::LogMapper1d >::value_type *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	size_t val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:LogMapper1dVector_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_insert" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LogMapper1dVector_insert" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::LogMapper1d >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LogMapper1d >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LogMapper1dVector_insert" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::iterator""'");
	}
	}
	ecode3 = SWIG_AsVal_size_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LogMapper1dVector_insert" "', argument " "3"" of type '" "std::vector< npstat::LogMapper1d >::size_type""'");
	}
	arg3 = static_cast< std::vector< npstat::LogMapper1d >::size_type >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__LogMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LogMapper1dVector_insert" "', argument " "4"" of type '" "std::vector< npstat::LogMapper1d >::value_type const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LogMapper1dVector_insert" "', argument " "4"" of type '" "std::vector< npstat::LogMapper1d >::value_type const &""'");
	}
	arg4 = reinterpret_cast< std::vector< npstat::LogMapper1d >::value_type * >(argp4);
	{
	try {
	std_vector_Sl_npstat_LogMapper1d_Sg__insert__SWIG_1(arg1,arg2,arg3,(npstat::LogMapper1d const &)*arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_insert(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LogMapper1d >::iterator > *>(iter) != 0));
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__LogMapper1d, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_LogMapper1dVector_insert__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LogMapper1d >::iterator > *>(iter) != 0));
	if (_v) {
	{
	int res = SWIG_AsVal_size_t(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__LogMapper1d, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_LogMapper1dVector_insert__SWIG_1(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LogMapper1dVector_insert'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::LogMapper1d >::insert(std::vector< npstat::LogMapper1d >::iterator,std::vector< npstat::LogMapper1d >::value_type const &)\n"
	" std::vector< npstat::LogMapper1d >::insert(std::vector< npstat::LogMapper1d >::iterator,std::vector< npstat::LogMapper1d >::size_type,std::vector< npstat::LogMapper1d >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_reserve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	std::vector< npstat::LogMapper1d >::size_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LogMapper1dVector_reserve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_reserve" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LogMapper1dVector_reserve" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LogMapper1d >::size_type >(val2);
	{
	try {
	(arg1)->reserve(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogMapper1dVector_capacity(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LogMapper1d >::size_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:LogMapper1dVector_capacity",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogMapper1dVector_capacity" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	result = ((std::vector< npstat::LogMapper1d > const *)arg1)->capacity();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_LogMapper1dVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LogMapper1d > arg1 = (std::vector< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LogMapper1dVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogMapper1dVector" "', argument " "1"" of type '" "std::vector< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LogMapper1d > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject LogMapper1dVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_npstat__LogMapper1d_std__allocatorT_npstat__LogMapper1d_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_LinInterpolatedTable1D__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::LinInterpolatedTable1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_LinInterpolatedTable1D",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinInterpolatedTable1D" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	{
	try {
	result = (npstat::LinInterpolatedTable1D *)new npstat::LinInterpolatedTable1D(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTable1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LinInterpolatedTable1D__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTable1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_LinInterpolatedTable1D")) SWIG_fail;
	{
	try {
	result = (npstat::LinInterpolatedTable1D *)new npstat::LinInterpolatedTable1D();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTable1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_LinInterpolatedTable1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTable1D arg1 = (npstat::LinInterpolatedTable1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LinInterpolatedTable1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTable1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinInterpolatedTable1D" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1D___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTable1D arg1 = (npstat::LinInterpolatedTable1D ) 0 ;
	double *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:LinInterpolatedTable1D___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1D___call__" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinInterpolatedTable1D___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	{
	try {
	result = (double)((npstat::LinInterpolatedTable1D const )arg1)->operator ()((double const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1D___eq__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTable1D arg1 = (npstat::LinInterpolatedTable1D ) 0 ;
	npstat::LinInterpolatedTable1D *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:LinInterpolatedTable1D___eq__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1D___eq__" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinInterpolatedTable1D___eq__" "', argument " "2"" of type '" "npstat::LinInterpolatedTable1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinInterpolatedTable1D___eq__" "', argument " "2"" of type '" "npstat::LinInterpolatedTable1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTable1D const )arg1)->operator ==((npstat::LinInterpolatedTable1D const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1D___ne__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTable1D arg1 = (npstat::LinInterpolatedTable1D ) 0 ;
	npstat::LinInterpolatedTable1D *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:LinInterpolatedTable1D___ne__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1D___ne__" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinInterpolatedTable1D___ne__" "', argument " "2"" of type '" "npstat::LinInterpolatedTable1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinInterpolatedTable1D___ne__" "', argument " "2"" of type '" "npstat::LinInterpolatedTable1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTable1D const )arg1)->operator !=((npstat::LinInterpolatedTable1D const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1D_xmin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTable1D arg1 = (npstat::LinInterpolatedTable1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1D_xmin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1D_xmin" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp1);
	{
	try {
	result = (double)((npstat::LinInterpolatedTable1D const *)arg1)->xmin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1D_xmax(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTable1D arg1 = (npstat::LinInterpolatedTable1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1D_xmax",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1D_xmax" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp1);
	{
	try {
	result = (double)((npstat::LinInterpolatedTable1D const *)arg1)->xmax();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1D_npoints(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTable1D arg1 = (npstat::LinInterpolatedTable1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1D_npoints",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1D_npoints" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::LinInterpolatedTable1D const *)arg1)->npoints();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1D_leftExtrapolationLinear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTable1D arg1 = (npstat::LinInterpolatedTable1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1D_leftExtrapolationLinear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1D_leftExtrapolationLinear" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp1);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTable1D const *)arg1)->leftExtrapolationLinear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1D_rightExtrapolationLinear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTable1D arg1 = (npstat::LinInterpolatedTable1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1D_rightExtrapolationLinear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1D_rightExtrapolationLinear" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp1);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTable1D const *)arg1)->rightExtrapolationLinear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1D_data(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTable1D arg1 = (npstat::LinInterpolatedTable1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1D_data",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1D_data" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp1);
	{
	try {
	result = (double )((npstat::LinInterpolatedTable1D const )arg1)->data();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1D_isMonotonous(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTable1D arg1 = (npstat::LinInterpolatedTable1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1D_isMonotonous",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1D_isMonotonous" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp1);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTable1D const *)arg1)->isMonotonous();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1D_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTable1D arg1 = (npstat::LinInterpolatedTable1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1D_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1D_classId" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp1);
	{
	try {
	result = ((npstat::LinInterpolatedTable1D const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1D_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTable1D arg1 = (npstat::LinInterpolatedTable1D ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:LinInterpolatedTable1D_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1D_write" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinInterpolatedTable1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinInterpolatedTable1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::LinInterpolatedTable1D const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1D_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":LinInterpolatedTable1D_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::LinInterpolatedTable1D::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1D_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":LinInterpolatedTable1D_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::LinInterpolatedTable1D::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1D_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTable1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LinInterpolatedTable1D_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinInterpolatedTable1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinInterpolatedTable1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinInterpolatedTable1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::LinInterpolatedTable1D )npstat::LinInterpolatedTable1D::read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTable1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1D_inverse(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTable1D arg1 = (npstat::LinInterpolatedTable1D ) 0 ;
	unsigned int arg2 ;
	bool arg3 ;
	bool arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	bool val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::LinInterpolatedTable1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:LinInterpolatedTable1D_inverse",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1D_inverse" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinInterpolatedTable1D_inverse" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinInterpolatedTable1D_inverse" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	ecode4 = SWIG_AsVal_bool(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LinInterpolatedTable1D_inverse" "', argument " "4"" of type '" "bool""'");
	}
	arg4 = static_cast< bool >(val4);
	{
	try {
	result = (npstat::LinInterpolatedTable1D )((npstat::LinInterpolatedTable1D const )arg1)->inverse2(arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTable1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LinInterpolatedTable1D__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 = (double ) 0 ;
	unsigned int arg2 ;
	double arg3 ;
	double arg4 ;
	bool arg5 ;
	bool arg6 ;
	PyArrayObject *array1 = NULL ;
	int is_new_object1 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	npstat::LinInterpolatedTable1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_LinInterpolatedTable1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	{
	npy_intp size[1] = {
	-1
	};
	array1 = obj_to_array_contiguous_allow_conversion(obj0,
	NPY_DOUBLE,
	&is_new_object1);
	if (!array1 \|\| !require_dimensions(array1, 1) \|\|
	!require_size(array1, size, 1)) SWIG_fail;
	arg1 = (double*) array_data(array1);
	arg2 = (int) array_size(array1,0);
	}
	ecode3 = SWIG_AsVal_double(obj1, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LinInterpolatedTable1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj2, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LinInterpolatedTable1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_bool(obj3, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_LinInterpolatedTable1D" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	ecode6 = SWIG_AsVal_bool(obj4, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_LinInterpolatedTable1D" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	{
	try {
	result = (npstat::LinInterpolatedTable1D )new npstat::LinInterpolatedTable1D((double const )arg1,arg2,arg3,arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTable1D, SWIG_POINTER_NEW \| 0 );
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LinInterpolatedTable1D__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *arg1 = 0 ;
	unsigned int arg2 ;
	bool arg3 ;
	bool arg4 ;
	int res1 = SWIG_OLDOBJ ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	bool val3 ;
	int ecode3 = 0 ;
	bool val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::LinInterpolatedTable1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_LinInterpolatedTable1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	{
	std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > ptr = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinInterpolatedTable1D" "', argument " "1"" of type '" "std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinInterpolatedTable1D" "', argument " "1"" of type '" "std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &""'");
	}
	arg1 = ptr;
	}
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LinInterpolatedTable1D" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_bool(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LinInterpolatedTable1D" "', argument " "3"" of type '" "bool""'");
	}
	arg3 = static_cast< bool >(val3);
	ecode4 = SWIG_AsVal_bool(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LinInterpolatedTable1D" "', argument " "4"" of type '" "bool""'");
	}
	arg4 = static_cast< bool >(val4);
	{
	try {
	result = (npstat::LinInterpolatedTable1D )new npstat::LinInterpolatedTable1D((std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)arg1,arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTable1D, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LinInterpolatedTable1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 0) {
	return _wrap_new_LinInterpolatedTable1D__SWIG_3(self, args);
	}
	if (argc == 1) {
	int _v;
	{
	int res = SWIG_AsVal_double(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_LinInterpolatedTable1D__SWIG_2(self, args);
	}
	}
	if (argc == 4) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_LinInterpolatedTable1D__SWIG_5(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	{
	_v = is_array(argv[0]) \|\| PySequence_Check(argv[0]);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_LinInterpolatedTable1D__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LinInterpolatedTable1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LinInterpolatedTable1D::LinInterpolatedTable1D(double)\n"
	" npstat::LinInterpolatedTable1D::LinInterpolatedTable1D()\n"
	" npstat::LinInterpolatedTable1D::LinInterpolatedTable1D(double const *,unsigned int,double,double,bool,bool)\n"
	" npstat::LinInterpolatedTable1D::LinInterpolatedTable1D(std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &,unsigned int,bool,bool)\n");
	return 0;
	}


	SWIGINTERN PyObject LinInterpolatedTable1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__LinInterpolatedTable1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveRecord_LinInterpolatedTable1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTable1D *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveRecord< npstat::LinInterpolatedTable1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveRecord_LinInterpolatedTable1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveRecord_LinInterpolatedTable1D" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveRecord_LinInterpolatedTable1D" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveRecord_LinInterpolatedTable1D" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveRecord_LinInterpolatedTable1D" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveRecord< npstat::LinInterpolatedTable1D > )new gs::ArchiveRecord< npstat::LinInterpolatedTable1D >((npstat::LinInterpolatedTable1D const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTable1D_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveRecord_LinInterpolatedTable1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveRecord< npstat::LinInterpolatedTable1D > arg1 = (gs::ArchiveRecord< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveRecord_LinInterpolatedTable1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTable1D_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveRecord_LinInterpolatedTable1D" "', argument " "1"" of type '" "gs::ArchiveRecord< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveRecord< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveRecord_LinInterpolatedTable1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTable1D_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPRecord__SWIG_73(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LinInterpolatedTable1D *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveRecord< npstat::LinInterpolatedTable1D > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPRecord",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::LinInterpolatedTable1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPRecord" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPRecord" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR Record< npstat::LinInterpolatedTable1D >((npstat::LinInterpolatedTable1D const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveRecord< npstat::LinInterpolatedTable1D >(static_cast< const gs::ArchiveRecord< npstat::LinInterpolatedTable1D >& >(result))), SWIGTYPE_p_gs__ArchiveRecordT_npstat__LinInterpolatedTable1D_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LinInterpolatedTable1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< npstat::LinInterpolatedTable1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_LinInterpolatedTable1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LinInterpolatedTable1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LinInterpolatedTable1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_LinInterpolatedTable1D" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTable1D > )new gs::Reference< npstat::LinInterpolatedTable1D >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTable1D_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LinInterpolatedTable1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::LinInterpolatedTable1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_LinInterpolatedTable1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LinInterpolatedTable1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LinInterpolatedTable1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_LinInterpolatedTable1D" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_LinInterpolatedTable1D" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTable1D > )new gs::Reference< npstat::LinInterpolatedTable1D >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTable1D_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LinInterpolatedTable1D__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::LinInterpolatedTable1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_LinInterpolatedTable1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LinInterpolatedTable1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LinInterpolatedTable1D" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_LinInterpolatedTable1D" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LinInterpolatedTable1D" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_LinInterpolatedTable1D" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LinInterpolatedTable1D" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< npstat::LinInterpolatedTable1D > )new gs::Reference< npstat::LinInterpolatedTable1D >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTable1D_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LinInterpolatedTable1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_LinInterpolatedTable1D__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_LinInterpolatedTable1D__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_LinInterpolatedTable1D__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_LinInterpolatedTable1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< npstat::LinInterpolatedTable1D >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< npstat::LinInterpolatedTable1D >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< npstat::LinInterpolatedTable1D >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_LinInterpolatedTable1D_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTable1D > arg1 = (gs::Reference< npstat::LinInterpolatedTable1D > ) 0 ;
	unsigned long arg2 ;
	npstat::LinInterpolatedTable1D arg3 = (npstat::LinInterpolatedTable1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_LinInterpolatedTable1D_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTable1D_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LinInterpolatedTable1D_restore" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTable1D > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTable1D > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LinInterpolatedTable1D_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_LinInterpolatedTable1D_restore" "', argument " "3"" of type '" "npstat::LinInterpolatedTable1D *""'");
	}
	arg3 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp3);
	{
	try {
	((gs::Reference< npstat::LinInterpolatedTable1D > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_LinInterpolatedTable1D_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTable1D > arg1 = (gs::Reference< npstat::LinInterpolatedTable1D > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTable1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_LinInterpolatedTable1D_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTable1D_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LinInterpolatedTable1D_retrieve" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTable1D > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTable1D > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LinInterpolatedTable1D_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (npstat::LinInterpolatedTable1D )gs_Reference_Sl_npstat_LinInterpolatedTable1D_Sg__retrieve((gs::Reference< npstat::LinInterpolatedTable1D > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTable1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_LinInterpolatedTable1D_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTable1D > arg1 = (gs::Reference< npstat::LinInterpolatedTable1D > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LinInterpolatedTable1D result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_LinInterpolatedTable1D_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTable1D_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LinInterpolatedTable1D_getValue" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTable1D > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTable1D > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LinInterpolatedTable1D_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_npstat_LinInterpolatedTable1D_Sg__getValue((gs::Reference< npstat::LinInterpolatedTable1D > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::LinInterpolatedTable1D(static_cast< const npstat::LinInterpolatedTable1D& >(result))), SWIGTYPE_p_npstat__LinInterpolatedTable1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_LinInterpolatedTable1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::LinInterpolatedTable1D > arg1 = (gs::Reference< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_LinInterpolatedTable1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTable1D_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_LinInterpolatedTable1D" "', argument " "1"" of type '" "gs::Reference< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_LinInterpolatedTable1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_npstat__LinInterpolatedTable1D_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_iterator(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	PyObject arg2 = (PyObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	swig::SwigPyIterator *result = 0 ;

	arg2 = &obj0;
	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1DVector_iterator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_iterator" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	result = (swig::SwigPyIterator *)std_vector_Sl_npstat_LinInterpolatedTable1D_Sg__iterator(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___nonzero__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1DVector___nonzero__",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector___nonzero__" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	result = (bool)std_vector_Sl_npstat_LinInterpolatedTable1D_Sg____nonzero__((std::vector< npstat::LinInterpolatedTable1D > const *)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___bool__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1DVector___bool__",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector___bool__" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	result = (bool)std_vector_Sl_npstat_LinInterpolatedTable1D_Sg____bool__((std::vector< npstat::LinInterpolatedTable1D > const *)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___len__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::size_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1DVector___len__",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector___len__" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	result = std_vector_Sl_npstat_LinInterpolatedTable1D_Sg____len__((std::vector< npstat::LinInterpolatedTable1D > const *)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___getslice__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::difference_type arg2 ;
	std::vector< npstat::LinInterpolatedTable1D >::difference_type arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LinInterpolatedTable1DVector___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector___getslice__" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinInterpolatedTable1DVector___getslice__" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinInterpolatedTable1DVector___getslice__" "', argument " "3"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::difference_type >(val3);
	{
	try {
	try {
	result = (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > *)std_vector_Sl_npstat_LinInterpolatedTable1D_Sg____getslice__(arg1,arg2,arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___setslice____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::difference_type arg2 ;
	std::vector< npstat::LinInterpolatedTable1D >::difference_type arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LinInterpolatedTable1DVector___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector___setslice__" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinInterpolatedTable1DVector___setslice__" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinInterpolatedTable1DVector___setslice__" "', argument " "3"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::difference_type >(val3);
	{
	try {
	try {
	std_vector_Sl_npstat_LinInterpolatedTable1D_Sg____setslice____SWIG_0(arg1,arg2,arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___setslice____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::difference_type arg2 ;
	std::vector< npstat::LinInterpolatedTable1D >::difference_type arg3 ;
	std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	int res4 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:LinInterpolatedTable1DVector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector___setslice__" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinInterpolatedTable1DVector___setslice__" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinInterpolatedTable1DVector___setslice__" "', argument " "3"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::difference_type >(val3);
	{
	std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > ptr = (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > )0;
	res4 = swig::asptr(obj3, &ptr);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LinInterpolatedTable1DVector___setslice__" "', argument " "4"" of type '" "std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinInterpolatedTable1DVector___setslice__" "', argument " "4"" of type '" "std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > const &""'");
	}
	arg4 = ptr;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_LinInterpolatedTable1D_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > const &)*arg4);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (SWIG_IsNewObj(res4)) delete arg4;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res4)) delete arg4;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___setslice__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_LinInterpolatedTable1DVector___setslice____SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[3], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_LinInterpolatedTable1DVector___setslice____SWIG_1(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LinInterpolatedTable1DVector___setslice__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::LinInterpolatedTable1D >::__setslice__(std::vector< npstat::LinInterpolatedTable1D >::difference_type,std::vector< npstat::LinInterpolatedTable1D >::difference_type)\n"
	" std::vector< npstat::LinInterpolatedTable1D >::__setslice__(std::vector< npstat::LinInterpolatedTable1D >::difference_type,std::vector< npstat::LinInterpolatedTable1D >::difference_type,std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___delslice__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::difference_type arg2 ;
	std::vector< npstat::LinInterpolatedTable1D >::difference_type arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LinInterpolatedTable1DVector___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector___delslice__" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinInterpolatedTable1DVector___delslice__" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinInterpolatedTable1DVector___delslice__" "', argument " "3"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::difference_type >(val3);
	{
	try {
	try {
	std_vector_Sl_npstat_LinInterpolatedTable1D_Sg____delslice__(arg1,arg2,arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___delitem____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::difference_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LinInterpolatedTable1DVector___delitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector___delitem__" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinInterpolatedTable1DVector___delitem__" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::difference_type >(val2);
	{
	try {
	try {
	std_vector_Sl_npstat_LinInterpolatedTable1D_Sg____delitem____SWIG_0(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___getitem____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LinInterpolatedTable1DVector___getitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector___getitem__" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinInterpolatedTable1DVector___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	try {
	try {
	result = (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > *)std_vector_Sl_npstat_LinInterpolatedTable1D_Sg____getitem____SWIG_0(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___setitem____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res3 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LinInterpolatedTable1DVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector___setitem__" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinInterpolatedTable1DVector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > ptr = (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > )0;
	res3 = swig::asptr(obj2, &ptr);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LinInterpolatedTable1DVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinInterpolatedTable1DVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > const &""'");
	}
	arg3 = ptr;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_LinInterpolatedTable1D_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > const &)*arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (SWIG_IsNewObj(res3)) delete arg3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res3)) delete arg3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___setitem____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LinInterpolatedTable1DVector___setitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector___setitem__" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinInterpolatedTable1DVector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_LinInterpolatedTable1D_Sg____setitem____SWIG_1(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___delitem____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LinInterpolatedTable1DVector___delitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector___delitem__" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinInterpolatedTable1DVector___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_LinInterpolatedTable1D_Sg____delitem____SWIG_1(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___delitem__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	return _wrap_LinInterpolatedTable1DVector___delitem____SWIG_1(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_LinInterpolatedTable1DVector___delitem____SWIG_0(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LinInterpolatedTable1DVector___delitem__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::LinInterpolatedTable1D >::__delitem__(std::vector< npstat::LinInterpolatedTable1D >::difference_type)\n"
	" std::vector< npstat::LinInterpolatedTable1D >::__delitem__(PySliceObject *)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___getitem____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::difference_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::value_type *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LinInterpolatedTable1DVector___getitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector___getitem__" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinInterpolatedTable1DVector___getitem__" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::difference_type >(val2);
	{
	try {
	try {
	result = (std::vector< npstat::LinInterpolatedTable1D >::value_type ) &std_vector_Sl_npstat_LinInterpolatedTable1D_Sg____getitem____SWIG_1((std::vector< npstat::LinInterpolatedTable1D > const )arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___getitem__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	return _wrap_LinInterpolatedTable1DVector___getitem____SWIG_0(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_LinInterpolatedTable1DVector___getitem____SWIG_1(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LinInterpolatedTable1DVector___getitem__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::LinInterpolatedTable1D >::__getitem__(PySliceObject *)\n"
	" std::vector< npstat::LinInterpolatedTable1D >::__getitem__(std::vector< npstat::LinInterpolatedTable1D >::difference_type) const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___setitem____SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::difference_type arg2 ;
	std::vector< npstat::LinInterpolatedTable1D >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LinInterpolatedTable1DVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector___setitem__" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinInterpolatedTable1DVector___setitem__" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::difference_type >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LinInterpolatedTable1DVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinInterpolatedTable1DVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D >::value_type * >(argp3);
	{
	try {
	try {
	std_vector_Sl_npstat_LinInterpolatedTable1D_Sg____setitem____SWIG_2(arg1,arg2,(npstat::LinInterpolatedTable1D const &)*arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector___setitem__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	return _wrap_LinInterpolatedTable1DVector___setitem____SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	int res = swig::asptr(argv[2], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_LinInterpolatedTable1DVector___setitem____SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_LinInterpolatedTable1DVector___setitem____SWIG_2(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LinInterpolatedTable1DVector___setitem__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::LinInterpolatedTable1D >::__setitem__(PySliceObject *,std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > const &)\n"
	" std::vector< npstat::LinInterpolatedTable1D >::__setitem__(PySliceObject *)\n"
	" std::vector< npstat::LinInterpolatedTable1D >::__setitem__(std::vector< npstat::LinInterpolatedTable1D >::difference_type,std::vector< npstat::LinInterpolatedTable1D >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_pop(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::value_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1DVector_pop",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_pop" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	try {
	result = std_vector_Sl_npstat_LinInterpolatedTable1D_Sg__pop(arg1);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new std::vector< npstat::LinInterpolatedTable1D >::value_type(static_cast< const std::vector< npstat::LinInterpolatedTable1D >::value_type& >(result))), SWIGTYPE_p_npstat__LinInterpolatedTable1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_append(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::value_type *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LinInterpolatedTable1DVector_append",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_append" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinInterpolatedTable1DVector_append" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::value_type const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinInterpolatedTable1DVector_append" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::value_type const &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D >::value_type * >(argp2);
	{
	try {
	std_vector_Sl_npstat_LinInterpolatedTable1D_Sg__append(arg1,(npstat::LinInterpolatedTable1D const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LinInterpolatedTable1DVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_LinInterpolatedTable1DVector")) SWIG_fail;
	{
	try {
	result = (std::vector< npstat::LinInterpolatedTable1D > *)new std::vector< npstat::LinInterpolatedTable1D >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LinInterpolatedTable1DVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > *arg1 = 0 ;
	int res1 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_LinInterpolatedTable1DVector",&obj0)) SWIG_fail;
	{
	std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > ptr = (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinInterpolatedTable1DVector" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinInterpolatedTable1DVector" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > const &""'");
	}
	arg1 = ptr;
	}
	{
	try {
	result = (std::vector< npstat::LinInterpolatedTable1D > )new std::vector< npstat::LinInterpolatedTable1D >((std::vector< npstat::LinInterpolatedTable1D > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_empty(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1DVector_empty",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_empty" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	result = (bool)((std::vector< npstat::LinInterpolatedTable1D > const *)arg1)->empty();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_size(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::size_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1DVector_size",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_size" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	result = ((std::vector< npstat::LinInterpolatedTable1D > const *)arg1)->size();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_swap(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LinInterpolatedTable1DVector_swap",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_swap" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinInterpolatedTable1DVector_swap" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D > &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinInterpolatedTable1DVector_swap" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D > &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp2);
	{
	try {
	(arg1)->swap(*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_begin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1DVector_begin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_begin" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	result = (arg1)->begin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::LinInterpolatedTable1D >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_end(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1DVector_end",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_end" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	result = (arg1)->end();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::LinInterpolatedTable1D >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_rbegin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::reverse_iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1DVector_rbegin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_rbegin" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	result = (arg1)->rbegin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::LinInterpolatedTable1D >::reverse_iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_rend(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::reverse_iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1DVector_rend",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_rend" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	result = (arg1)->rend();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::LinInterpolatedTable1D >::reverse_iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1DVector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_clear" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_get_allocator(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< std::allocator< npstat::LinInterpolatedTable1D > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1DVector_get_allocator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_get_allocator" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	result = ((std::vector< npstat::LinInterpolatedTable1D > const *)arg1)->get_allocator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new std::vector< npstat::LinInterpolatedTable1D >::allocator_type(static_cast< const std::vector< npstat::LinInterpolatedTable1D >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_npstat__LinInterpolatedTable1D_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LinInterpolatedTable1DVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D >::size_type arg1 ;
	size_t val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_LinInterpolatedTable1DVector",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_size_t(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinInterpolatedTable1DVector" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::size_type""'");
	}
	arg1 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::size_type >(val1);
	{
	try {
	result = (std::vector< npstat::LinInterpolatedTable1D > *)new std::vector< npstat::LinInterpolatedTable1D >(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_pop_back(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1DVector_pop_back",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_pop_back" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	(arg1)->pop_back();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_resize__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::size_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LinInterpolatedTable1DVector_resize",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_resize" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinInterpolatedTable1DVector_resize" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::size_type >(val2);
	{
	try {
	(arg1)->resize(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_erase__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::iterator arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"OO:LinInterpolatedTable1DVector_erase",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_erase" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinInterpolatedTable1DVector_erase" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::LinInterpolatedTable1D >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LinInterpolatedTable1D >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinInterpolatedTable1DVector_erase" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::iterator""'");
	}
	}
	{
	try {
	result = std_vector_Sl_npstat_LinInterpolatedTable1D_Sg__erase__SWIG_0(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::LinInterpolatedTable1D >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_erase__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::iterator arg2 ;
	std::vector< npstat::LinInterpolatedTable1D >::iterator arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	swig::SwigPyIterator *iter3 = 0 ;
	int res3 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LinInterpolatedTable1DVector_erase",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_erase" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinInterpolatedTable1DVector_erase" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::LinInterpolatedTable1D >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LinInterpolatedTable1D >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinInterpolatedTable1DVector_erase" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::iterator""'");
	}
	}
	res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res3) \|\| !iter3) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinInterpolatedTable1DVector_erase" "', argument " "3"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::LinInterpolatedTable1D >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LinInterpolatedTable1D >::iterator > >(iter3);
	if (iter_t) {
	arg3 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinInterpolatedTable1DVector_erase" "', argument " "3"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::iterator""'");
	}
	}
	{
	try {
	result = std_vector_Sl_npstat_LinInterpolatedTable1D_Sg__erase__SWIG_1(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::LinInterpolatedTable1D >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_erase(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LinInterpolatedTable1D >::iterator > *>(iter) != 0));
	if (_v) {
	return _wrap_LinInterpolatedTable1DVector_erase__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LinInterpolatedTable1D >::iterator > *>(iter) != 0));
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LinInterpolatedTable1D >::iterator > *>(iter) != 0));
	if (_v) {
	return _wrap_LinInterpolatedTable1DVector_erase__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LinInterpolatedTable1DVector_erase'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::LinInterpolatedTable1D >::erase(std::vector< npstat::LinInterpolatedTable1D >::iterator)\n"
	" std::vector< npstat::LinInterpolatedTable1D >::erase(std::vector< npstat::LinInterpolatedTable1D >::iterator,std::vector< npstat::LinInterpolatedTable1D >::iterator)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_new_LinInterpolatedTable1DVector__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D >::size_type arg1 ;
	std::vector< npstat::LinInterpolatedTable1D >::value_type *arg2 = 0 ;
	size_t val1 ;
	int ecode1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_LinInterpolatedTable1DVector",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_size_t(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinInterpolatedTable1DVector" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::size_type""'");
	}
	arg1 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::size_type >(val1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinInterpolatedTable1DVector" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::value_type const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinInterpolatedTable1DVector" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::value_type const &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D >::value_type * >(argp2);
	{
	try {
	result = (std::vector< npstat::LinInterpolatedTable1D > )new std::vector< npstat::LinInterpolatedTable1D >(arg1,(std::vector< npstat::LinInterpolatedTable1D >::value_type const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LinInterpolatedTable1DVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 0) {
	return _wrap_new_LinInterpolatedTable1DVector__SWIG_0(self, args);
	}
	if (argc == 1) {
	int _v;
	{
	int res = SWIG_AsVal_size_t(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_LinInterpolatedTable1DVector__SWIG_2(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_LinInterpolatedTable1DVector__SWIG_1(self, args);
	}
	}
	if (argc == 2) {
	int _v;
	{
	int res = SWIG_AsVal_size_t(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_LinInterpolatedTable1DVector__SWIG_3(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LinInterpolatedTable1DVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::LinInterpolatedTable1D >::vector()\n"
	" std::vector< npstat::LinInterpolatedTable1D >::vector(std::vector< npstat::LinInterpolatedTable1D > const &)\n"
	" std::vector< npstat::LinInterpolatedTable1D >::vector(std::vector< npstat::LinInterpolatedTable1D >::size_type)\n"
	" std::vector< npstat::LinInterpolatedTable1D >::vector(std::vector< npstat::LinInterpolatedTable1D >::size_type,std::vector< npstat::LinInterpolatedTable1D >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_push_back(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::value_type *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LinInterpolatedTable1DVector_push_back",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_push_back" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinInterpolatedTable1DVector_push_back" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::value_type const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinInterpolatedTable1DVector_push_back" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::value_type const &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D >::value_type * >(argp2);
	{
	try {
	(arg1)->push_back((std::vector< npstat::LinInterpolatedTable1D >::value_type const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_front(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::value_type *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1DVector_front",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_front" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	result = (std::vector< npstat::LinInterpolatedTable1D >::value_type ) &((std::vector< npstat::LinInterpolatedTable1D > const )arg1)->front();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_back(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::value_type *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1DVector_back",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_back" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	result = (std::vector< npstat::LinInterpolatedTable1D >::value_type ) &((std::vector< npstat::LinInterpolatedTable1D > const )arg1)->back();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_assign(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::size_type arg2 ;
	std::vector< npstat::LinInterpolatedTable1D >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LinInterpolatedTable1DVector_assign",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_assign" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinInterpolatedTable1DVector_assign" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::size_type >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LinInterpolatedTable1DVector_assign" "', argument " "3"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinInterpolatedTable1DVector_assign" "', argument " "3"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D >::value_type * >(argp3);
	{
	try {
	(arg1)->assign(arg2,(std::vector< npstat::LinInterpolatedTable1D >::value_type const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_resize__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::size_type arg2 ;
	std::vector< npstat::LinInterpolatedTable1D >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LinInterpolatedTable1DVector_resize",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_resize" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinInterpolatedTable1DVector_resize" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::size_type >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LinInterpolatedTable1DVector_resize" "', argument " "3"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinInterpolatedTable1DVector_resize" "', argument " "3"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D >::value_type * >(argp3);
	{
	try {
	(arg1)->resize(arg2,(std::vector< npstat::LinInterpolatedTable1D >::value_type const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_resize(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_size_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_LinInterpolatedTable1DVector_resize__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_size_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_LinInterpolatedTable1DVector_resize__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LinInterpolatedTable1DVector_resize'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::LinInterpolatedTable1D >::resize(std::vector< npstat::LinInterpolatedTable1D >::size_type)\n"
	" std::vector< npstat::LinInterpolatedTable1D >::resize(std::vector< npstat::LinInterpolatedTable1D >::size_type,std::vector< npstat::LinInterpolatedTable1D >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_insert__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::iterator arg2 ;
	std::vector< npstat::LinInterpolatedTable1D >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LinInterpolatedTable1DVector_insert",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_insert" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinInterpolatedTable1DVector_insert" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::LinInterpolatedTable1D >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LinInterpolatedTable1D >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinInterpolatedTable1DVector_insert" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::iterator""'");
	}
	}
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LinInterpolatedTable1DVector_insert" "', argument " "3"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinInterpolatedTable1DVector_insert" "', argument " "3"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D >::value_type * >(argp3);
	{
	try {
	result = std_vector_Sl_npstat_LinInterpolatedTable1D_Sg__insert__SWIG_0(arg1,arg2,(npstat::LinInterpolatedTable1D const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::LinInterpolatedTable1D >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_insert__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::iterator arg2 ;
	std::vector< npstat::LinInterpolatedTable1D >::size_type arg3 ;
	std::vector< npstat::LinInterpolatedTable1D >::value_type *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	size_t val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:LinInterpolatedTable1DVector_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_insert" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinInterpolatedTable1DVector_insert" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::LinInterpolatedTable1D >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LinInterpolatedTable1D >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinInterpolatedTable1DVector_insert" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::iterator""'");
	}
	}
	ecode3 = SWIG_AsVal_size_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinInterpolatedTable1DVector_insert" "', argument " "3"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::size_type""'");
	}
	arg3 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::size_type >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LinInterpolatedTable1DVector_insert" "', argument " "4"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::value_type const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinInterpolatedTable1DVector_insert" "', argument " "4"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::value_type const &""'");
	}
	arg4 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D >::value_type * >(argp4);
	{
	try {
	std_vector_Sl_npstat_LinInterpolatedTable1D_Sg__insert__SWIG_1(arg1,arg2,arg3,(npstat::LinInterpolatedTable1D const &)*arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_insert(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LinInterpolatedTable1D >::iterator > *>(iter) != 0));
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_LinInterpolatedTable1DVector_insert__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::LinInterpolatedTable1D >::iterator > *>(iter) != 0));
	if (_v) {
	{
	int res = SWIG_AsVal_size_t(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_LinInterpolatedTable1DVector_insert__SWIG_1(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LinInterpolatedTable1DVector_insert'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::LinInterpolatedTable1D >::insert(std::vector< npstat::LinInterpolatedTable1D >::iterator,std::vector< npstat::LinInterpolatedTable1D >::value_type const &)\n"
	" std::vector< npstat::LinInterpolatedTable1D >::insert(std::vector< npstat::LinInterpolatedTable1D >::iterator,std::vector< npstat::LinInterpolatedTable1D >::size_type,std::vector< npstat::LinInterpolatedTable1D >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_reserve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::size_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LinInterpolatedTable1DVector_reserve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_reserve" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinInterpolatedTable1DVector_reserve" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::LinInterpolatedTable1D >::size_type >(val2);
	{
	try {
	(arg1)->reserve(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LinInterpolatedTable1DVector_capacity(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D >::size_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:LinInterpolatedTable1DVector_capacity",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinInterpolatedTable1DVector_capacity" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	result = ((std::vector< npstat::LinInterpolatedTable1D > const *)arg1)->capacity();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_LinInterpolatedTable1DVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::LinInterpolatedTable1D > arg1 = (std::vector< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LinInterpolatedTable1DVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinInterpolatedTable1DVector" "', argument " "1"" of type '" "std::vector< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject LinInterpolatedTable1DVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_npstat__LinInterpolatedTable1D_std__allocatorT_npstat__LinInterpolatedTable1D_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DensityScan1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistribution1D *arg1 = 0 ;
	double arg2 ;
	unsigned long arg3 ;
	double arg4 ;
	double arg5 ;
	unsigned int arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	npstat::DensityScan1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_DensityScan1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DensityScan1D" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScan1D" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DensityScan1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DensityScan1D" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DensityScan1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DensityScan1D" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_DensityScan1D" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	{
	try {
	result = (npstat::DensityScan1D )new npstat::DensityScan1D((npstat::AbsDistribution1D const &)arg1,arg2,arg3,arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DensityScan1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DensityScan1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistribution1D *arg1 = 0 ;
	double arg2 ;
	unsigned long arg3 ;
	double arg4 ;
	double arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	npstat::DensityScan1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_DensityScan1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DensityScan1D" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScan1D" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DensityScan1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DensityScan1D" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DensityScan1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DensityScan1D" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	{
	try {
	result = (npstat::DensityScan1D )new npstat::DensityScan1D((npstat::AbsDistribution1D const &)arg1,arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DensityScan1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DensityScan1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[7] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 6) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DensityScan1D__SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DensityScan1D__SWIG_0(self, args);
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DensityScan1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::DensityScan1D::DensityScan1D(npstat::AbsDistribution1D const &,double,unsigned long,double,double,unsigned int)\n"
	" npstat::DensityScan1D::DensityScan1D(npstat::AbsDistribution1D const &,double,unsigned long,double,double)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DensityScan1D___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScan1D arg1 = (npstat::DensityScan1D ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DensityScan1D___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScan1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityScan1D___call__" "', argument " "1"" of type '" "npstat::DensityScan1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScan1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DensityScan1D___call__" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DensityScan1D___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::DensityScan1D const )arg1)->operator ()((unsigned int const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DensityScan1D_averageDensity(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScan1D arg1 = (npstat::DensityScan1D ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DensityScan1D_averageDensity",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScan1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityScan1D_averageDensity" "', argument " "1"" of type '" "npstat::DensityScan1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScan1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DensityScan1D_averageDensity" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (double)((npstat::DensityScan1D const *)arg1)->averageDensity(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DensityScan1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScan1D arg1 = (npstat::DensityScan1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DensityScan1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScan1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DensityScan1D" "', argument " "1"" of type '" "npstat::DensityScan1D *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScan1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DensityScan1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__DensityScan1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DensityDiscretizationError1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistribution1D *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::DensityDiscretizationError1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DensityDiscretizationError1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DensityDiscretizationError1D" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityDiscretizationError1D" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DensityDiscretizationError1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DensityDiscretizationError1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (npstat::DensityDiscretizationError1D )new npstat::DensityDiscretizationError1D((npstat::AbsDistribution1D const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DensityDiscretizationError1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DensityDiscretizationError1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityDiscretizationError1D arg1 = (npstat::DensityDiscretizationError1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DensityDiscretizationError1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityDiscretizationError1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DensityDiscretizationError1D" "', argument " "1"" of type '" "npstat::DensityDiscretizationError1D *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityDiscretizationError1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DensityDiscretizationError1D___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityDiscretizationError1D arg1 = (npstat::DensityDiscretizationError1D ) 0 ;
	double *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DensityDiscretizationError1D___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityDiscretizationError1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityDiscretizationError1D___call__" "', argument " "1"" of type '" "npstat::DensityDiscretizationError1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityDiscretizationError1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DensityDiscretizationError1D___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	{
	try {
	result = (double)((npstat::DensityDiscretizationError1D const )arg1)->operator ()((double const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DensityDiscretizationError1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__DensityDiscretizationError1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DensityScan1D_Linear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistribution1D *arg1 = 0 ;
	npstat::LinearMapper1dTmpl< double > *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::DensityScan1DTrans< npstat::LinearMapper1d > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DensityScan1D_Linear",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DensityScan1D_Linear" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScan1D_Linear" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistribution1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinearMapper1dTmplT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DensityScan1D_Linear" "', argument " "2"" of type '" "npstat::LinearMapper1dTmpl< double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScan1D_Linear" "', argument " "2"" of type '" "npstat::LinearMapper1dTmpl< double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::LinearMapper1dTmpl< double > * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DensityScan1D_Linear" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (npstat::DensityScan1DTrans< npstat::LinearMapper1d > )new npstat::DensityScan1DTrans< npstat::LinearMapper1d >((npstat::AbsDistribution1D const &)arg1,(npstat::LinearMapper1dTmpl< double > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__LinearMapper1dTmplT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DensityScan1D_Linear___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScan1DTrans< npstat::LinearMapper1d > arg1 = (npstat::DensityScan1DTrans< npstat::LinearMapper1d > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DensityScan1D_Linear___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__LinearMapper1dTmplT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityScan1D_Linear___call__" "', argument " "1"" of type '" "npstat::DensityScan1DTrans< npstat::LinearMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScan1DTrans< npstat::LinearMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DensityScan1D_Linear___call__" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DensityScan1D_Linear___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::DensityScan1DTrans< npstat::LinearMapper1d > const )arg1)->operator ()((unsigned int const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DensityScan1D_Linear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScan1DTrans< npstat::LinearMapper1d > arg1 = (npstat::DensityScan1DTrans< npstat::LinearMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DensityScan1D_Linear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__LinearMapper1dTmplT_double_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DensityScan1D_Linear" "', argument " "1"" of type '" "npstat::DensityScan1DTrans< npstat::LinearMapper1d > *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScan1DTrans< npstat::LinearMapper1d > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DensityScan1D_Linear_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__LinearMapper1dTmplT_double_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DensityScan1D_Log(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistribution1D *arg1 = 0 ;
	npstat::LogMapper1d *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::DensityScan1DTrans< npstat::LogMapper1d > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DensityScan1D_Log",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DensityScan1D_Log" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScan1D_Log" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistribution1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LogMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DensityScan1D_Log" "', argument " "2"" of type '" "npstat::LogMapper1d const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScan1D_Log" "', argument " "2"" of type '" "npstat::LogMapper1d const &""'");
	}
	arg2 = reinterpret_cast< npstat::LogMapper1d * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DensityScan1D_Log" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (npstat::DensityScan1DTrans< npstat::LogMapper1d > )new npstat::DensityScan1DTrans< npstat::LogMapper1d >((npstat::AbsDistribution1D const &)arg1,(npstat::LogMapper1d const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__LogMapper1d_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DensityScan1D_Log___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScan1DTrans< npstat::LogMapper1d > arg1 = (npstat::DensityScan1DTrans< npstat::LogMapper1d > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DensityScan1D_Log___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__LogMapper1d_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityScan1D_Log___call__" "', argument " "1"" of type '" "npstat::DensityScan1DTrans< npstat::LogMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScan1DTrans< npstat::LogMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DensityScan1D_Log___call__" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DensityScan1D_Log___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::DensityScan1DTrans< npstat::LogMapper1d > const )arg1)->operator ()((unsigned int const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DensityScan1D_Log(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScan1DTrans< npstat::LogMapper1d > arg1 = (npstat::DensityScan1DTrans< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DensityScan1D_Log",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__LogMapper1d_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DensityScan1D_Log" "', argument " "1"" of type '" "npstat::DensityScan1DTrans< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScan1DTrans< npstat::LogMapper1d > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DensityScan1D_Log_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__LogMapper1d_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DensityScan1D_Circular(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistribution1D *arg1 = 0 ;
	npstat::CircularMapper1d *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::DensityScan1DTrans< npstat::CircularMapper1d > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DensityScan1D_Circular",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DensityScan1D_Circular" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScan1D_Circular" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistribution1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__CircularMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DensityScan1D_Circular" "', argument " "2"" of type '" "npstat::CircularMapper1d const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScan1D_Circular" "', argument " "2"" of type '" "npstat::CircularMapper1d const &""'");
	}
	arg2 = reinterpret_cast< npstat::CircularMapper1d * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DensityScan1D_Circular" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (npstat::DensityScan1DTrans< npstat::CircularMapper1d > )new npstat::DensityScan1DTrans< npstat::CircularMapper1d >((npstat::AbsDistribution1D const &)arg1,(npstat::CircularMapper1d const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__CircularMapper1d_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DensityScan1D_Circular___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScan1DTrans< npstat::CircularMapper1d > arg1 = (npstat::DensityScan1DTrans< npstat::CircularMapper1d > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DensityScan1D_Circular___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__CircularMapper1d_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityScan1D_Circular___call__" "', argument " "1"" of type '" "npstat::DensityScan1DTrans< npstat::CircularMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScan1DTrans< npstat::CircularMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DensityScan1D_Circular___call__" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DensityScan1D_Circular___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::DensityScan1DTrans< npstat::CircularMapper1d > const )arg1)->operator ()((unsigned int const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DensityScan1D_Circular(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScan1DTrans< npstat::CircularMapper1d > arg1 = (npstat::DensityScan1DTrans< npstat::CircularMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DensityScan1D_Circular",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__CircularMapper1d_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DensityScan1D_Circular" "', argument " "1"" of type '" "npstat::DensityScan1DTrans< npstat::CircularMapper1d > *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScan1DTrans< npstat::CircularMapper1d > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DensityScan1D_Circular_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__CircularMapper1d_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DensityScan1D_Interpolated(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistribution1D *arg1 = 0 ;
	npstat::LinInterpolatedTable1D *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::DensityScan1DTrans< npstat::LinInterpolatedTable1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DensityScan1D_Interpolated",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DensityScan1D_Interpolated" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScan1D_Interpolated" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistribution1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DensityScan1D_Interpolated" "', argument " "2"" of type '" "npstat::LinInterpolatedTable1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScan1D_Interpolated" "', argument " "2"" of type '" "npstat::LinInterpolatedTable1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::LinInterpolatedTable1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DensityScan1D_Interpolated" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (npstat::DensityScan1DTrans< npstat::LinInterpolatedTable1D > )new npstat::DensityScan1DTrans< npstat::LinInterpolatedTable1D >((npstat::AbsDistribution1D const &)arg1,(npstat::LinInterpolatedTable1D const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__LinInterpolatedTable1D_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DensityScan1D_Interpolated___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScan1DTrans< npstat::LinInterpolatedTable1D > arg1 = (npstat::DensityScan1DTrans< npstat::LinInterpolatedTable1D > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DensityScan1D_Interpolated___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__LinInterpolatedTable1D_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityScan1D_Interpolated___call__" "', argument " "1"" of type '" "npstat::DensityScan1DTrans< npstat::LinInterpolatedTable1D > const *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScan1DTrans< npstat::LinInterpolatedTable1D > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DensityScan1D_Interpolated___call__" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DensityScan1D_Interpolated___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::DensityScan1DTrans< npstat::LinInterpolatedTable1D > const )arg1)->operator ()((unsigned int const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DensityScan1D_Interpolated(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScan1DTrans< npstat::LinInterpolatedTable1D > arg1 = (npstat::DensityScan1DTrans< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DensityScan1D_Interpolated",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__LinInterpolatedTable1D_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DensityScan1D_Interpolated" "', argument " "1"" of type '" "npstat::DensityScan1DTrans< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScan1DTrans< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DensityScan1D_Interpolated_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__LinInterpolatedTable1D_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DensityScan1D_Funct(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistribution1D *arg1 = 0 ;
	npstat::Functor1< double,double > *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::DensityScan1DTrans< npstat::Functor1< double,double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DensityScan1D_Funct",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DensityScan1D_Funct" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScan1D_Funct" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistribution1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__Functor1T_double_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DensityScan1D_Funct" "', argument " "2"" of type '" "npstat::Functor1< double,double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScan1D_Funct" "', argument " "2"" of type '" "npstat::Functor1< double,double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::Functor1< double,double > * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DensityScan1D_Funct" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (npstat::DensityScan1DTrans< npstat::Functor1< double,double > > )new npstat::DensityScan1DTrans< npstat::Functor1< double,double > >((npstat::AbsDistribution1D const &)arg1,(npstat::Functor1< double,double > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__Functor1T_double_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DensityScan1D_Funct___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScan1DTrans< npstat::Functor1< double,double > > arg1 = (npstat::DensityScan1DTrans< npstat::Functor1< double,double > > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DensityScan1D_Funct___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__Functor1T_double_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityScan1D_Funct___call__" "', argument " "1"" of type '" "npstat::DensityScan1DTrans< npstat::Functor1< double,double > > const *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScan1DTrans< npstat::Functor1< double,double > > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DensityScan1D_Funct___call__" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DensityScan1D_Funct___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::DensityScan1DTrans< npstat::Functor1< double,double > > const )arg1)->operator ()((unsigned int const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DensityScan1D_Funct(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScan1DTrans< npstat::Functor1< double,double > > arg1 = (npstat::DensityScan1DTrans< npstat::Functor1< double,double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DensityScan1D_Funct",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__Functor1T_double_double_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DensityScan1D_Funct" "', argument " "1"" of type '" "npstat::DensityScan1DTrans< npstat::Functor1< double,double > > *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScan1DTrans< npstat::Functor1< double,double > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DensityScan1D_Funct_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__Functor1T_double_double_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DensityScan1D_Fcn(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistribution1D *arg1 = 0 ;
	npstat::FcnFunctor1< double,double > *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::DensityScan1DTrans< npstat::FcnFunctor1< double,double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DensityScan1D_Fcn",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DensityScan1D_Fcn" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScan1D_Fcn" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistribution1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__FcnFunctor1T_double_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DensityScan1D_Fcn" "', argument " "2"" of type '" "npstat::FcnFunctor1< double,double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScan1D_Fcn" "', argument " "2"" of type '" "npstat::FcnFunctor1< double,double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::FcnFunctor1< double,double > * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DensityScan1D_Fcn" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (npstat::DensityScan1DTrans< npstat::FcnFunctor1< double,double > > )new npstat::DensityScan1DTrans< npstat::FcnFunctor1< double,double > >((npstat::AbsDistribution1D const &)arg1,(npstat::FcnFunctor1< double,double > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__FcnFunctor1T_double_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DensityScan1D_Fcn___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScan1DTrans< npstat::FcnFunctor1< double,double > > arg1 = (npstat::DensityScan1DTrans< npstat::FcnFunctor1< double,double > > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DensityScan1D_Fcn___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__FcnFunctor1T_double_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityScan1D_Fcn___call__" "', argument " "1"" of type '" "npstat::DensityScan1DTrans< npstat::FcnFunctor1< double,double > > const *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScan1DTrans< npstat::FcnFunctor1< double,double > > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DensityScan1D_Fcn___call__" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DensityScan1D_Fcn___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::DensityScan1DTrans< npstat::FcnFunctor1< double,double > > const )arg1)->operator ()((unsigned int const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DensityScan1D_Fcn(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScan1DTrans< npstat::FcnFunctor1< double,double > > arg1 = (npstat::DensityScan1DTrans< npstat::FcnFunctor1< double,double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DensityScan1D_Fcn",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__FcnFunctor1T_double_double_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DensityScan1D_Fcn" "', argument " "1"" of type '" "npstat::DensityScan1DTrans< npstat::FcnFunctor1< double,double > > *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScan1DTrans< npstat::FcnFunctor1< double,double > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DensityScan1D_Fcn_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__DensityScan1DTransT_npstat__FcnFunctor1T_double_double_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_AbsInterpolatedDistribution1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsInterpolatedDistribution1D arg1 = (npstat::AbsInterpolatedDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_AbsInterpolatedDistribution1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsInterpolatedDistribution1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AbsInterpolatedDistribution1D" "', argument " "1"" of type '" "npstat::AbsInterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsInterpolatedDistribution1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsInterpolatedDistribution1D_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsInterpolatedDistribution1D arg1 = (npstat::AbsInterpolatedDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::AbsInterpolatedDistribution1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsInterpolatedDistribution1D_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsInterpolatedDistribution1D_clone" "', argument " "1"" of type '" "npstat::AbsInterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsInterpolatedDistribution1D * >(argp1);
	{
	try {
	result = (npstat::AbsInterpolatedDistribution1D )((npstat::AbsInterpolatedDistribution1D const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__AbsInterpolatedDistribution1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsInterpolatedDistribution1D_add(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsInterpolatedDistribution1D arg1 = (npstat::AbsInterpolatedDistribution1D ) 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:AbsInterpolatedDistribution1D_add",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsInterpolatedDistribution1D_add" "', argument " "1"" of type '" "npstat::AbsInterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsInterpolatedDistribution1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbsInterpolatedDistribution1D_add" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbsInterpolatedDistribution1D_add" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbsInterpolatedDistribution1D_add" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	(arg1)->add((npstat::AbsDistribution1D const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsInterpolatedDistribution1D_replace(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsInterpolatedDistribution1D arg1 = (npstat::AbsInterpolatedDistribution1D ) 0 ;
	unsigned int arg2 ;
	npstat::AbsDistribution1D *arg3 = 0 ;
	double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:AbsInterpolatedDistribution1D_replace",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsInterpolatedDistribution1D_replace" "', argument " "1"" of type '" "npstat::AbsInterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsInterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbsInterpolatedDistribution1D_replace" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbsInterpolatedDistribution1D_replace" "', argument " "3"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbsInterpolatedDistribution1D_replace" "', argument " "3"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg3 = reinterpret_cast< npstat::AbsDistribution1D * >(argp3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbsInterpolatedDistribution1D_replace" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	(arg1)->replace(arg2,(npstat::AbsDistribution1D const &)*arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsInterpolatedDistribution1D_setWeight(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsInterpolatedDistribution1D arg1 = (npstat::AbsInterpolatedDistribution1D ) 0 ;
	unsigned int arg2 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:AbsInterpolatedDistribution1D_setWeight",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsInterpolatedDistribution1D_setWeight" "', argument " "1"" of type '" "npstat::AbsInterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsInterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbsInterpolatedDistribution1D_setWeight" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbsInterpolatedDistribution1D_setWeight" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	(arg1)->setWeight(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsInterpolatedDistribution1D_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsInterpolatedDistribution1D arg1 = (npstat::AbsInterpolatedDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsInterpolatedDistribution1D_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsInterpolatedDistribution1D_clear" "', argument " "1"" of type '" "npstat::AbsInterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsInterpolatedDistribution1D * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsInterpolatedDistribution1D_size(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsInterpolatedDistribution1D arg1 = (npstat::AbsInterpolatedDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsInterpolatedDistribution1D_size",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsInterpolatedDistribution1D_size" "', argument " "1"" of type '" "npstat::AbsInterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsInterpolatedDistribution1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::AbsInterpolatedDistribution1D const *)arg1)->size();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsInterpolatedDistribution1D_expectedSize(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsInterpolatedDistribution1D arg1 = (npstat::AbsInterpolatedDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsInterpolatedDistribution1D_expectedSize",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsInterpolatedDistribution1D_expectedSize" "', argument " "1"" of type '" "npstat::AbsInterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsInterpolatedDistribution1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::AbsInterpolatedDistribution1D const *)arg1)->expectedSize();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsInterpolatedDistribution1D_normalizeAutomatically(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsInterpolatedDistribution1D arg1 = (npstat::AbsInterpolatedDistribution1D ) 0 ;
	bool arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:AbsInterpolatedDistribution1D_normalizeAutomatically",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsInterpolatedDistribution1D_normalizeAutomatically" "', argument " "1"" of type '" "npstat::AbsInterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsInterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbsInterpolatedDistribution1D_normalizeAutomatically" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	{
	try {
	(arg1)->normalizeAutomatically(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject AbsInterpolatedDistribution1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsInterpolatedDistribution1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_VerticallyInterpolatedDistribution1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::VerticallyInterpolatedDistribution1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_VerticallyInterpolatedDistribution1D",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VerticallyInterpolatedDistribution1D" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	{
	try {
	result = (npstat::VerticallyInterpolatedDistribution1D *)new npstat::VerticallyInterpolatedDistribution1D(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_VerticallyInterpolatedDistribution1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::VerticallyInterpolatedDistribution1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_VerticallyInterpolatedDistribution1D")) SWIG_fail;
	{
	try {
	result = (npstat::VerticallyInterpolatedDistribution1D *)new npstat::VerticallyInterpolatedDistribution1D();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_VerticallyInterpolatedDistribution1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 0) {
	return _wrap_new_VerticallyInterpolatedDistribution1D__SWIG_1(self, args);
	}
	if (argc == 1) {
	int _v;
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_VerticallyInterpolatedDistribution1D__SWIG_0(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_VerticallyInterpolatedDistribution1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::VerticallyInterpolatedDistribution1D::VerticallyInterpolatedDistribution1D(unsigned int)\n"
	" npstat::VerticallyInterpolatedDistribution1D::VerticallyInterpolatedDistribution1D()\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_VerticallyInterpolatedDistribution1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::VerticallyInterpolatedDistribution1D arg1 = (npstat::VerticallyInterpolatedDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_VerticallyInterpolatedDistribution1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VerticallyInterpolatedDistribution1D" "', argument " "1"" of type '" "npstat::VerticallyInterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::VerticallyInterpolatedDistribution1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_VerticallyInterpolatedDistribution1D_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::VerticallyInterpolatedDistribution1D arg1 = (npstat::VerticallyInterpolatedDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::VerticallyInterpolatedDistribution1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:VerticallyInterpolatedDistribution1D_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerticallyInterpolatedDistribution1D_clone" "', argument " "1"" of type '" "npstat::VerticallyInterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::VerticallyInterpolatedDistribution1D * >(argp1);
	{
	try {
	result = (npstat::VerticallyInterpolatedDistribution1D )((npstat::VerticallyInterpolatedDistribution1D const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_VerticallyInterpolatedDistribution1D_add(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::VerticallyInterpolatedDistribution1D arg1 = (npstat::VerticallyInterpolatedDistribution1D ) 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:VerticallyInterpolatedDistribution1D_add",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerticallyInterpolatedDistribution1D_add" "', argument " "1"" of type '" "npstat::VerticallyInterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::VerticallyInterpolatedDistribution1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VerticallyInterpolatedDistribution1D_add" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VerticallyInterpolatedDistribution1D_add" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VerticallyInterpolatedDistribution1D_add" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	(arg1)->add((npstat::AbsDistribution1D const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_VerticallyInterpolatedDistribution1D_replace(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::VerticallyInterpolatedDistribution1D arg1 = (npstat::VerticallyInterpolatedDistribution1D ) 0 ;
	unsigned int arg2 ;
	npstat::AbsDistribution1D *arg3 = 0 ;
	double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:VerticallyInterpolatedDistribution1D_replace",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerticallyInterpolatedDistribution1D_replace" "', argument " "1"" of type '" "npstat::VerticallyInterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::VerticallyInterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerticallyInterpolatedDistribution1D_replace" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VerticallyInterpolatedDistribution1D_replace" "', argument " "3"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VerticallyInterpolatedDistribution1D_replace" "', argument " "3"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg3 = reinterpret_cast< npstat::AbsDistribution1D * >(argp3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VerticallyInterpolatedDistribution1D_replace" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	(arg1)->replace(arg2,(npstat::AbsDistribution1D const &)*arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_VerticallyInterpolatedDistribution1D_setWeight(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::VerticallyInterpolatedDistribution1D arg1 = (npstat::VerticallyInterpolatedDistribution1D ) 0 ;
	unsigned int arg2 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:VerticallyInterpolatedDistribution1D_setWeight",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerticallyInterpolatedDistribution1D_setWeight" "', argument " "1"" of type '" "npstat::VerticallyInterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::VerticallyInterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerticallyInterpolatedDistribution1D_setWeight" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VerticallyInterpolatedDistribution1D_setWeight" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	(arg1)->setWeight(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_VerticallyInterpolatedDistribution1D_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::VerticallyInterpolatedDistribution1D arg1 = (npstat::VerticallyInterpolatedDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:VerticallyInterpolatedDistribution1D_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerticallyInterpolatedDistribution1D_clear" "', argument " "1"" of type '" "npstat::VerticallyInterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::VerticallyInterpolatedDistribution1D * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_VerticallyInterpolatedDistribution1D_normalizeAutomatically(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::VerticallyInterpolatedDistribution1D arg1 = (npstat::VerticallyInterpolatedDistribution1D ) 0 ;
	bool arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:VerticallyInterpolatedDistribution1D_normalizeAutomatically",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerticallyInterpolatedDistribution1D_normalizeAutomatically" "', argument " "1"" of type '" "npstat::VerticallyInterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::VerticallyInterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerticallyInterpolatedDistribution1D_normalizeAutomatically" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	{
	try {
	(arg1)->normalizeAutomatically(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_VerticallyInterpolatedDistribution1D_size(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::VerticallyInterpolatedDistribution1D arg1 = (npstat::VerticallyInterpolatedDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:VerticallyInterpolatedDistribution1D_size",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerticallyInterpolatedDistribution1D_size" "', argument " "1"" of type '" "npstat::VerticallyInterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::VerticallyInterpolatedDistribution1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::VerticallyInterpolatedDistribution1D const *)arg1)->size();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_VerticallyInterpolatedDistribution1D_expectedSize(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::VerticallyInterpolatedDistribution1D arg1 = (npstat::VerticallyInterpolatedDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:VerticallyInterpolatedDistribution1D_expectedSize",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerticallyInterpolatedDistribution1D_expectedSize" "', argument " "1"" of type '" "npstat::VerticallyInterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::VerticallyInterpolatedDistribution1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::VerticallyInterpolatedDistribution1D const *)arg1)->expectedSize();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_VerticallyInterpolatedDistribution1D_density(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::VerticallyInterpolatedDistribution1D arg1 = (npstat::VerticallyInterpolatedDistribution1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:VerticallyInterpolatedDistribution1D_density",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerticallyInterpolatedDistribution1D_density" "', argument " "1"" of type '" "npstat::VerticallyInterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::VerticallyInterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerticallyInterpolatedDistribution1D_density" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::VerticallyInterpolatedDistribution1D const *)arg1)->density(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_VerticallyInterpolatedDistribution1D_cdf(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::VerticallyInterpolatedDistribution1D arg1 = (npstat::VerticallyInterpolatedDistribution1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:VerticallyInterpolatedDistribution1D_cdf",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerticallyInterpolatedDistribution1D_cdf" "', argument " "1"" of type '" "npstat::VerticallyInterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::VerticallyInterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerticallyInterpolatedDistribution1D_cdf" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::VerticallyInterpolatedDistribution1D const *)arg1)->cdf(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_VerticallyInterpolatedDistribution1D_exceedance(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::VerticallyInterpolatedDistribution1D arg1 = (npstat::VerticallyInterpolatedDistribution1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:VerticallyInterpolatedDistribution1D_exceedance",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerticallyInterpolatedDistribution1D_exceedance" "', argument " "1"" of type '" "npstat::VerticallyInterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::VerticallyInterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerticallyInterpolatedDistribution1D_exceedance" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::VerticallyInterpolatedDistribution1D const *)arg1)->exceedance(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_VerticallyInterpolatedDistribution1D_quantile(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::VerticallyInterpolatedDistribution1D arg1 = (npstat::VerticallyInterpolatedDistribution1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:VerticallyInterpolatedDistribution1D_quantile",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerticallyInterpolatedDistribution1D_quantile" "', argument " "1"" of type '" "npstat::VerticallyInterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::VerticallyInterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VerticallyInterpolatedDistribution1D_quantile" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::VerticallyInterpolatedDistribution1D const *)arg1)->quantile(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_VerticallyInterpolatedDistribution1D_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::VerticallyInterpolatedDistribution1D arg1 = (npstat::VerticallyInterpolatedDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:VerticallyInterpolatedDistribution1D_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VerticallyInterpolatedDistribution1D_classId" "', argument " "1"" of type '" "npstat::VerticallyInterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::VerticallyInterpolatedDistribution1D * >(argp1);
	{
	try {
	result = ((npstat::VerticallyInterpolatedDistribution1D const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_VerticallyInterpolatedDistribution1D_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":VerticallyInterpolatedDistribution1D_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::VerticallyInterpolatedDistribution1D::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_VerticallyInterpolatedDistribution1D_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":VerticallyInterpolatedDistribution1D_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::VerticallyInterpolatedDistribution1D::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject VerticallyInterpolatedDistribution1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__VerticallyInterpolatedDistribution1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_UCharAbsBandwidthCV1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< unsigned char,double > arg1 = (npstat::AbsBandwidthCV1D< unsigned char,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_UCharAbsBandwidthCV1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_unsigned_char_double_double_unsigned_char_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UCharAbsBandwidthCV1D" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< unsigned char,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< unsigned char,double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharAbsBandwidthCV1D___call____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< unsigned char,double > arg1 = (npstat::AbsBandwidthCV1D< unsigned char,double > ) 0 ;
	npstat::HistoND< unsigned char > *arg2 = 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	npstat::AbsPolyFilter1D *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:UCharAbsBandwidthCV1D___call__",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_unsigned_char_double_double_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< unsigned char,double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< unsigned char,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< unsigned char > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	arg5 = reinterpret_cast< npstat::AbsPolyFilter1D * >(argp5);
	{
	try {
	result = (double)((npstat::AbsBandwidthCV1D< unsigned char,double > const )arg1)->operator ()((npstat::HistoND< unsigned char > const &)arg2,(double const )arg3,arg4,(npstat::AbsPolyFilter1D const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharAbsBandwidthCV1D___call____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< unsigned char,double > arg1 = (npstat::AbsBandwidthCV1D< unsigned char,double > ) 0 ;
	npstat::HistoND< unsigned char > *arg2 = 0 ;
	double arg3 ;
	double arg4 = (double ) 0 ;
	unsigned int arg5 ;
	npstat::AbsPolyFilter1D *arg6 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	void *argp6 = 0 ;
	int res6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:UCharAbsBandwidthCV1D___call__",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_unsigned_char_double_double_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< unsigned char,double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< unsigned char,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< unsigned char > * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "4"" of type '" "double const *""'");
	}
	arg4 = reinterpret_cast< double * >(argp4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res6)) {
	SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "6"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	if (!argp6) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "6"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	arg6 = reinterpret_cast< npstat::AbsPolyFilter1D * >(argp6);
	{
	try {
	result = (double)((npstat::AbsBandwidthCV1D< unsigned char,double > const )arg1)->operator ()((npstat::HistoND< unsigned char > const &)arg2,arg3,(double const )arg4,arg5,(npstat::AbsPolyFilter1D const &)arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharAbsBandwidthCV1D___call____SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< unsigned char,double > arg1 = (npstat::AbsBandwidthCV1D< unsigned char,double > ) 0 ;
	npstat::HistoND< unsigned char > *arg2 = 0 ;
	std::pair< double,unsigned char > arg3 = (std::pair< double,unsigned char > ) 0 ;
	unsigned long arg4 ;
	double arg5 = (double ) 0 ;
	unsigned int arg6 ;
	npstat::AbsPolyFilter1D *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned long val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:UCharAbsBandwidthCV1D___call__",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_unsigned_char_double_double_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< unsigned char,double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< unsigned char,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< unsigned char > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__pairT_double_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "3"" of type '" "std::pair< double,unsigned char > const *""'");
	}
	arg3 = reinterpret_cast< std::pair< double,unsigned char > * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "4"" of type '" "unsigned long""'");
	}
	arg4 = static_cast< unsigned long >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "double const *""'");
	}
	arg5 = reinterpret_cast< double * >(argp5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "7"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UCharAbsBandwidthCV1D___call__" "', argument " "7"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	arg7 = reinterpret_cast< npstat::AbsPolyFilter1D * >(argp7);
	{
	try {
	result = (double)((npstat::AbsBandwidthCV1D< unsigned char,double > const )arg1)->operator ()((npstat::HistoND< unsigned char > const &)arg2,(std::pair< double,unsigned char > const )arg3,arg4,(double const )arg5,arg6,(npstat::AbsPolyFilter1D const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharAbsBandwidthCV1D___call__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[8] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 7) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCV1DT_unsigned_char_double_double_unsigned_char_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_UCharAbsBandwidthCV1D___call____SWIG_0(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCV1DT_unsigned_char_double_double_unsigned_char_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_UCharAbsBandwidthCV1D___call____SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCV1DT_unsigned_char_double_double_unsigned_char_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__pairT_double_unsigned_char_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_UCharAbsBandwidthCV1D___call____SWIG_2(self, args);
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'UCharAbsBandwidthCV1D___call__'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::AbsBandwidthCV1D< unsigned char,double >::operator ()(npstat::HistoND< unsigned char > const &,double const *,unsigned int,npstat::AbsPolyFilter1D const &) const\n"
	" npstat::AbsBandwidthCV1D< unsigned char,double >::operator ()(npstat::HistoND< unsigned char > const &,double,double const *,unsigned int,npstat::AbsPolyFilter1D const &) const\n"
	" npstat::AbsBandwidthCV1D< unsigned char,double >::operator ()(npstat::HistoND< unsigned char > const &,std::pair< double,unsigned char > const ,unsigned long,double const ,unsigned int,npstat::AbsPolyFilter1D const &) const\n");
	return 0;
	}


	SWIGINTERN PyObject UCharAbsBandwidthCV1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsBandwidthCV1DT_unsigned_char_double_double_unsigned_char_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_IntAbsBandwidthCV1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< int,double > arg1 = (npstat::AbsBandwidthCV1D< int,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_IntAbsBandwidthCV1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_int_double_double_int_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntAbsBandwidthCV1D" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< int,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< int,double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntAbsBandwidthCV1D___call____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< int,double > arg1 = (npstat::AbsBandwidthCV1D< int,double > ) 0 ;
	npstat::HistoND< int > *arg2 = 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	npstat::AbsPolyFilter1D *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:IntAbsBandwidthCV1D___call__",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_int_double_double_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< int,double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< int,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_int_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< int > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< int > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< int > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	arg5 = reinterpret_cast< npstat::AbsPolyFilter1D * >(argp5);
	{
	try {
	result = (double)((npstat::AbsBandwidthCV1D< int,double > const )arg1)->operator ()((npstat::HistoND< int > const &)arg2,(double const )arg3,arg4,(npstat::AbsPolyFilter1D const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntAbsBandwidthCV1D___call____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< int,double > arg1 = (npstat::AbsBandwidthCV1D< int,double > ) 0 ;
	npstat::HistoND< int > *arg2 = 0 ;
	double arg3 ;
	double arg4 = (double ) 0 ;
	unsigned int arg5 ;
	npstat::AbsPolyFilter1D *arg6 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	void *argp6 = 0 ;
	int res6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:IntAbsBandwidthCV1D___call__",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_int_double_double_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< int,double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< int,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_int_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< int > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< int > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< int > * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "4"" of type '" "double const *""'");
	}
	arg4 = reinterpret_cast< double * >(argp4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res6)) {
	SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "6"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	if (!argp6) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "6"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	arg6 = reinterpret_cast< npstat::AbsPolyFilter1D * >(argp6);
	{
	try {
	result = (double)((npstat::AbsBandwidthCV1D< int,double > const )arg1)->operator ()((npstat::HistoND< int > const &)arg2,arg3,(double const )arg4,arg5,(npstat::AbsPolyFilter1D const &)arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntAbsBandwidthCV1D___call____SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< int,double > arg1 = (npstat::AbsBandwidthCV1D< int,double > ) 0 ;
	npstat::HistoND< int > *arg2 = 0 ;
	std::pair< double,int > arg3 = (std::pair< double,int > ) 0 ;
	unsigned long arg4 ;
	double arg5 = (double ) 0 ;
	unsigned int arg6 ;
	npstat::AbsPolyFilter1D *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned long val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:IntAbsBandwidthCV1D___call__",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_int_double_double_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< int,double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< int,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_int_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< int > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< int > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< int > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__pairT_double_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "3"" of type '" "std::pair< double,int > const *""'");
	}
	arg3 = reinterpret_cast< std::pair< double,int > * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "4"" of type '" "unsigned long""'");
	}
	arg4 = static_cast< unsigned long >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "double const *""'");
	}
	arg5 = reinterpret_cast< double * >(argp5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "7"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntAbsBandwidthCV1D___call__" "', argument " "7"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	arg7 = reinterpret_cast< npstat::AbsPolyFilter1D * >(argp7);
	{
	try {
	result = (double)((npstat::AbsBandwidthCV1D< int,double > const )arg1)->operator ()((npstat::HistoND< int > const &)arg2,(std::pair< double,int > const )arg3,arg4,(double const )arg5,arg6,(npstat::AbsPolyFilter1D const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntAbsBandwidthCV1D___call__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[8] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 7) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCV1DT_int_double_double_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_IntAbsBandwidthCV1D___call____SWIG_0(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCV1DT_int_double_double_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_IntAbsBandwidthCV1D___call____SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCV1DT_int_double_double_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__pairT_double_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_IntAbsBandwidthCV1D___call____SWIG_2(self, args);
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'IntAbsBandwidthCV1D___call__'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::AbsBandwidthCV1D< int,double >::operator ()(npstat::HistoND< int > const &,double const *,unsigned int,npstat::AbsPolyFilter1D const &) const\n"
	" npstat::AbsBandwidthCV1D< int,double >::operator ()(npstat::HistoND< int > const &,double,double const *,unsigned int,npstat::AbsPolyFilter1D const &) const\n"
	" npstat::AbsBandwidthCV1D< int,double >::operator ()(npstat::HistoND< int > const &,std::pair< double,int > const ,unsigned long,double const ,unsigned int,npstat::AbsPolyFilter1D const &) const\n");
	return 0;
	}


	SWIGINTERN PyObject IntAbsBandwidthCV1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsBandwidthCV1DT_int_double_double_int_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_LLongAbsBandwidthCV1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< long long,double > arg1 = (npstat::AbsBandwidthCV1D< long long,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LLongAbsBandwidthCV1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_long_long_double_double_long_long_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LLongAbsBandwidthCV1D" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< long long,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< long long,double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongAbsBandwidthCV1D___call____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< long long,double > arg1 = (npstat::AbsBandwidthCV1D< long long,double > ) 0 ;
	npstat::HistoND< long long > *arg2 = 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	npstat::AbsPolyFilter1D *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:LLongAbsBandwidthCV1D___call__",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_long_long_double_double_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< long long,double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< long long,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< long long > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< long long > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< long long > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	arg5 = reinterpret_cast< npstat::AbsPolyFilter1D * >(argp5);
	{
	try {
	result = (double)((npstat::AbsBandwidthCV1D< long long,double > const )arg1)->operator ()((npstat::HistoND< long long > const &)arg2,(double const )arg3,arg4,(npstat::AbsPolyFilter1D const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongAbsBandwidthCV1D___call____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< long long,double > arg1 = (npstat::AbsBandwidthCV1D< long long,double > ) 0 ;
	npstat::HistoND< long long > *arg2 = 0 ;
	double arg3 ;
	double arg4 = (double ) 0 ;
	unsigned int arg5 ;
	npstat::AbsPolyFilter1D *arg6 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	void *argp6 = 0 ;
	int res6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:LLongAbsBandwidthCV1D___call__",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_long_long_double_double_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< long long,double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< long long,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< long long > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< long long > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< long long > * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "4"" of type '" "double const *""'");
	}
	arg4 = reinterpret_cast< double * >(argp4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res6)) {
	SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "6"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	if (!argp6) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "6"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	arg6 = reinterpret_cast< npstat::AbsPolyFilter1D * >(argp6);
	{
	try {
	result = (double)((npstat::AbsBandwidthCV1D< long long,double > const )arg1)->operator ()((npstat::HistoND< long long > const &)arg2,arg3,(double const )arg4,arg5,(npstat::AbsPolyFilter1D const &)arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongAbsBandwidthCV1D___call____SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< long long,double > arg1 = (npstat::AbsBandwidthCV1D< long long,double > ) 0 ;
	npstat::HistoND< long long > *arg2 = 0 ;
	std::pair< double,long long > arg3 = (std::pair< double,long long > ) 0 ;
	unsigned long arg4 ;
	double arg5 = (double ) 0 ;
	unsigned int arg6 ;
	npstat::AbsPolyFilter1D *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned long val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:LLongAbsBandwidthCV1D___call__",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_long_long_double_double_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< long long,double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< long long,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< long long > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< long long > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< long long > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__pairT_double_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "3"" of type '" "std::pair< double,long long > const *""'");
	}
	arg3 = reinterpret_cast< std::pair< double,long long > * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "4"" of type '" "unsigned long""'");
	}
	arg4 = static_cast< unsigned long >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "double const *""'");
	}
	arg5 = reinterpret_cast< double * >(argp5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "7"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LLongAbsBandwidthCV1D___call__" "', argument " "7"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	arg7 = reinterpret_cast< npstat::AbsPolyFilter1D * >(argp7);
	{
	try {
	result = (double)((npstat::AbsBandwidthCV1D< long long,double > const )arg1)->operator ()((npstat::HistoND< long long > const &)arg2,(std::pair< double,long long > const )arg3,arg4,(double const )arg5,arg6,(npstat::AbsPolyFilter1D const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongAbsBandwidthCV1D___call__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[8] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 7) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCV1DT_long_long_double_double_long_long_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_LLongAbsBandwidthCV1D___call____SWIG_0(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCV1DT_long_long_double_double_long_long_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_LLongAbsBandwidthCV1D___call____SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCV1DT_long_long_double_double_long_long_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__pairT_double_long_long_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_LLongAbsBandwidthCV1D___call____SWIG_2(self, args);
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LLongAbsBandwidthCV1D___call__'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::AbsBandwidthCV1D< long long,double >::operator ()(npstat::HistoND< long long > const &,double const *,unsigned int,npstat::AbsPolyFilter1D const &) const\n"
	" npstat::AbsBandwidthCV1D< long long,double >::operator ()(npstat::HistoND< long long > const &,double,double const *,unsigned int,npstat::AbsPolyFilter1D const &) const\n"
	" npstat::AbsBandwidthCV1D< long long,double >::operator ()(npstat::HistoND< long long > const &,std::pair< double,long long > const ,unsigned long,double const ,unsigned int,npstat::AbsPolyFilter1D const &) const\n");
	return 0;
	}


	SWIGINTERN PyObject LLongAbsBandwidthCV1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsBandwidthCV1DT_long_long_double_double_long_long_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_FloatAbsBandwidthCV1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< float,double > arg1 = (npstat::AbsBandwidthCV1D< float,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatAbsBandwidthCV1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_float_double_double_float_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatAbsBandwidthCV1D" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< float,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< float,double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatAbsBandwidthCV1D___call____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< float,double > arg1 = (npstat::AbsBandwidthCV1D< float,double > ) 0 ;
	npstat::HistoND< float > *arg2 = 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	npstat::AbsPolyFilter1D *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:FloatAbsBandwidthCV1D___call__",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_float_double_double_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< float,double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< float,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_float_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< float > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< float > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< float > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	arg5 = reinterpret_cast< npstat::AbsPolyFilter1D * >(argp5);
	{
	try {
	result = (double)((npstat::AbsBandwidthCV1D< float,double > const )arg1)->operator ()((npstat::HistoND< float > const &)arg2,(double const )arg3,arg4,(npstat::AbsPolyFilter1D const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatAbsBandwidthCV1D___call____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< float,double > arg1 = (npstat::AbsBandwidthCV1D< float,double > ) 0 ;
	npstat::HistoND< float > *arg2 = 0 ;
	double arg3 ;
	double arg4 = (double ) 0 ;
	unsigned int arg5 ;
	npstat::AbsPolyFilter1D *arg6 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	void *argp6 = 0 ;
	int res6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:FloatAbsBandwidthCV1D___call__",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_float_double_double_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< float,double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< float,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_float_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< float > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< float > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< float > * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "4"" of type '" "double const *""'");
	}
	arg4 = reinterpret_cast< double * >(argp4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res6)) {
	SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "6"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	if (!argp6) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "6"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	arg6 = reinterpret_cast< npstat::AbsPolyFilter1D * >(argp6);
	{
	try {
	result = (double)((npstat::AbsBandwidthCV1D< float,double > const )arg1)->operator ()((npstat::HistoND< float > const &)arg2,arg3,(double const )arg4,arg5,(npstat::AbsPolyFilter1D const &)arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatAbsBandwidthCV1D___call____SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< float,double > arg1 = (npstat::AbsBandwidthCV1D< float,double > ) 0 ;
	npstat::HistoND< float > *arg2 = 0 ;
	std::pair< double,float > arg3 = (std::pair< double,float > ) 0 ;
	unsigned long arg4 ;
	double arg5 = (double ) 0 ;
	unsigned int arg6 ;
	npstat::AbsPolyFilter1D *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned long val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:FloatAbsBandwidthCV1D___call__",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_float_double_double_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< float,double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< float,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_float_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< float > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< float > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< float > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__pairT_double_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "3"" of type '" "std::pair< double,float > const *""'");
	}
	arg3 = reinterpret_cast< std::pair< double,float > * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "4"" of type '" "unsigned long""'");
	}
	arg4 = static_cast< unsigned long >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "double const *""'");
	}
	arg5 = reinterpret_cast< double * >(argp5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "7"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatAbsBandwidthCV1D___call__" "', argument " "7"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	arg7 = reinterpret_cast< npstat::AbsPolyFilter1D * >(argp7);
	{
	try {
	result = (double)((npstat::AbsBandwidthCV1D< float,double > const )arg1)->operator ()((npstat::HistoND< float > const &)arg2,(std::pair< double,float > const )arg3,arg4,(double const )arg5,arg6,(npstat::AbsPolyFilter1D const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatAbsBandwidthCV1D___call__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[8] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 7) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCV1DT_float_double_double_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatAbsBandwidthCV1D___call____SWIG_0(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCV1DT_float_double_double_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatAbsBandwidthCV1D___call____SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCV1DT_float_double_double_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[2], (std::pair< double,float >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatAbsBandwidthCV1D___call____SWIG_2(self, args);
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatAbsBandwidthCV1D___call__'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::AbsBandwidthCV1D< float,double >::operator ()(npstat::HistoND< float > const &,double const *,unsigned int,npstat::AbsPolyFilter1D const &) const\n"
	" npstat::AbsBandwidthCV1D< float,double >::operator ()(npstat::HistoND< float > const &,double,double const *,unsigned int,npstat::AbsPolyFilter1D const &) const\n"
	" npstat::AbsBandwidthCV1D< float,double >::operator ()(npstat::HistoND< float > const &,std::pair< double,float > const ,unsigned long,double const ,unsigned int,npstat::AbsPolyFilter1D const &) const\n");
	return 0;
	}


	SWIGINTERN PyObject FloatAbsBandwidthCV1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsBandwidthCV1DT_float_double_double_float_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_DoubleAbsBandwidthCV1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< double,double > arg1 = (npstat::AbsBandwidthCV1D< double,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleAbsBandwidthCV1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_double_double_double_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleAbsBandwidthCV1D" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< double,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< double,double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleAbsBandwidthCV1D___call____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< double,double > arg1 = (npstat::AbsBandwidthCV1D< double,double > ) 0 ;
	npstat::HistoND< double > *arg2 = 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	npstat::AbsPolyFilter1D *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:DoubleAbsBandwidthCV1D___call__",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_double_double_double_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< double,double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< double,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< double > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	arg5 = reinterpret_cast< npstat::AbsPolyFilter1D * >(argp5);
	{
	try {
	result = (double)((npstat::AbsBandwidthCV1D< double,double > const )arg1)->operator ()((npstat::HistoND< double > const &)arg2,(double const )arg3,arg4,(npstat::AbsPolyFilter1D const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleAbsBandwidthCV1D___call____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< double,double > arg1 = (npstat::AbsBandwidthCV1D< double,double > ) 0 ;
	npstat::HistoND< double > *arg2 = 0 ;
	double arg3 ;
	double arg4 = (double ) 0 ;
	unsigned int arg5 ;
	npstat::AbsPolyFilter1D *arg6 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	void *argp6 = 0 ;
	int res6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:DoubleAbsBandwidthCV1D___call__",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_double_double_double_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< double,double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< double,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< double > * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "4"" of type '" "double const *""'");
	}
	arg4 = reinterpret_cast< double * >(argp4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res6)) {
	SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "6"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	if (!argp6) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "6"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	arg6 = reinterpret_cast< npstat::AbsPolyFilter1D * >(argp6);
	{
	try {
	result = (double)((npstat::AbsBandwidthCV1D< double,double > const )arg1)->operator ()((npstat::HistoND< double > const &)arg2,arg3,(double const )arg4,arg5,(npstat::AbsPolyFilter1D const &)arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleAbsBandwidthCV1D___call____SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCV1D< double,double > arg1 = (npstat::AbsBandwidthCV1D< double,double > ) 0 ;
	npstat::HistoND< double > *arg2 = 0 ;
	std::pair< double,double > arg3 = (std::pair< double,double > ) 0 ;
	unsigned long arg4 ;
	double arg5 = (double ) 0 ;
	unsigned int arg6 ;
	npstat::AbsPolyFilter1D *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned long val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:DoubleAbsBandwidthCV1D___call__",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCV1DT_double_double_double_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCV1D< double,double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCV1D< double,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "2"" of type '" "npstat::HistoND< double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< double > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__pairT_double_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "3"" of type '" "std::pair< double,double > const *""'");
	}
	arg3 = reinterpret_cast< std::pair< double,double > * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "4"" of type '" "unsigned long""'");
	}
	arg4 = static_cast< unsigned long >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "5"" of type '" "double const *""'");
	}
	arg5 = reinterpret_cast< double * >(argp5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "7"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleAbsBandwidthCV1D___call__" "', argument " "7"" of type '" "npstat::AbsPolyFilter1D const &""'");
	}
	arg7 = reinterpret_cast< npstat::AbsPolyFilter1D * >(argp7);
	{
	try {
	result = (double)((npstat::AbsBandwidthCV1D< double,double > const )arg1)->operator ()((npstat::HistoND< double > const &)arg2,(std::pair< double,double > const )arg3,arg4,(double const )arg5,arg6,(npstat::AbsPolyFilter1D const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleAbsBandwidthCV1D___call__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[8] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 7) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCV1DT_double_double_double_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleAbsBandwidthCV1D___call____SWIG_0(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCV1DT_double_double_double_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[5], 0, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleAbsBandwidthCV1D___call____SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCV1DT_double_double_double_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[2], (std::pair< double,double >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__AbsPolyFilter1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleAbsBandwidthCV1D___call____SWIG_2(self, args);
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleAbsBandwidthCV1D___call__'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::AbsBandwidthCV1D< double,double >::operator ()(npstat::HistoND< double > const &,double const *,unsigned int,npstat::AbsPolyFilter1D const &) const\n"
	" npstat::AbsBandwidthCV1D< double,double >::operator ()(npstat::HistoND< double > const &,double,double const *,unsigned int,npstat::AbsPolyFilter1D const &) const\n"
	" npstat::AbsBandwidthCV1D< double,double >::operator ()(npstat::HistoND< double > const &,std::pair< double,double > const ,unsigned long,double const ,unsigned int,npstat::AbsPolyFilter1D const &) const\n");
	return 0;
	}


	SWIGINTERN PyObject DoubleAbsBandwidthCV1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsBandwidthCV1DT_double_double_double_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_UCharAbsBandwidthCVND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCVND< unsigned char,npstat::ArrayND< double > > arg1 = (npstat::AbsBandwidthCVND< unsigned char,npstat::ArrayND< double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_UCharAbsBandwidthCVND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCVNDT_unsigned_char_npstat__ArrayNDT_double_1U_10U_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UCharAbsBandwidthCVND" "', argument " "1"" of type '" "npstat::AbsBandwidthCVND< unsigned char,npstat::ArrayND< double > > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCVND< unsigned char,npstat::ArrayND< double > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharAbsBandwidthCVND___call____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCVND< unsigned char,npstat::ArrayND< double > > arg1 = (npstat::AbsBandwidthCVND< unsigned char,npstat::ArrayND< double > > ) 0 ;
	npstat::HistoND< unsigned char > *arg2 = 0 ;
	npstat::ArrayND< double,1U,10U > *arg3 = 0 ;
	npstat::AbsPolyFilterND *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:UCharAbsBandwidthCVND___call__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCVNDT_unsigned_char_npstat__ArrayNDT_double_1U_10U_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharAbsBandwidthCVND___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCVND< unsigned char,npstat::ArrayND< double > > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCVND< unsigned char,npstat::ArrayND< double > > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UCharAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UCharAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< unsigned char > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UCharAbsBandwidthCVND___call__" "', argument " "3"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UCharAbsBandwidthCVND___call__" "', argument " "3"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	arg3 = reinterpret_cast< npstat::ArrayND< double,1U,10U > * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__AbsPolyFilterND, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "UCharAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UCharAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	arg4 = reinterpret_cast< npstat::AbsPolyFilterND * >(argp4);
	{
	try {
	result = (double)((npstat::AbsBandwidthCVND< unsigned char,npstat::ArrayND< double > > const )arg1)->operator ()((npstat::HistoND< unsigned char > const &)arg2,(npstat::ArrayND< double,1U,10U > const &)arg3,(npstat::AbsPolyFilterND const &)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharAbsBandwidthCVND___call____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCVND< unsigned char,npstat::ArrayND< double > > arg1 = (npstat::AbsBandwidthCVND< unsigned char,npstat::ArrayND< double > > ) 0 ;
	npstat::HistoND< unsigned char > *arg2 = 0 ;
	double arg3 ;
	npstat::ArrayND< double,1U,10U > *arg4 = 0 ;
	npstat::AbsPolyFilterND *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:UCharAbsBandwidthCVND___call__",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCVNDT_unsigned_char_npstat__ArrayNDT_double_1U_10U_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharAbsBandwidthCVND___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCVND< unsigned char,npstat::ArrayND< double > > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCVND< unsigned char,npstat::ArrayND< double > > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UCharAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UCharAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< unsigned char > * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UCharAbsBandwidthCVND___call__" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "UCharAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UCharAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	arg4 = reinterpret_cast< npstat::ArrayND< double,1U,10U > * >(argp4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__AbsPolyFilterND, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "UCharAbsBandwidthCVND___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UCharAbsBandwidthCVND___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	arg5 = reinterpret_cast< npstat::AbsPolyFilterND * >(argp5);
	{
	try {
	result = (double)((npstat::AbsBandwidthCVND< unsigned char,npstat::ArrayND< double > > const )arg1)->operator ()((npstat::HistoND< unsigned char > const &)arg2,arg3,(npstat::ArrayND< double,1U,10U > const &)arg4,(npstat::AbsPolyFilterND const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharAbsBandwidthCVND___call__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCVNDT_unsigned_char_npstat__ArrayNDT_double_1U_10U_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__AbsPolyFilterND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_UCharAbsBandwidthCVND___call____SWIG_0(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCVNDT_unsigned_char_npstat__ArrayNDT_double_1U_10U_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__AbsPolyFilterND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_UCharAbsBandwidthCVND___call____SWIG_1(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'UCharAbsBandwidthCVND___call__'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::AbsBandwidthCVND< unsigned char,npstat::ArrayND< double > >::operator ()(npstat::HistoND< unsigned char > const &,npstat::ArrayND< double,1U,10U > const &,npstat::AbsPolyFilterND const &) const\n"
	" npstat::AbsBandwidthCVND< unsigned char,npstat::ArrayND< double > >::operator ()(npstat::HistoND< unsigned char > const &,double,npstat::ArrayND< double,1U,10U > const &,npstat::AbsPolyFilterND const &) const\n");
	return 0;
	}


	SWIGINTERN PyObject UCharAbsBandwidthCVND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsBandwidthCVNDT_unsigned_char_npstat__ArrayNDT_double_1U_10U_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_IntAbsBandwidthCVND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCVND< int,npstat::ArrayND< double > > arg1 = (npstat::AbsBandwidthCVND< int,npstat::ArrayND< double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_IntAbsBandwidthCVND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCVNDT_int_npstat__ArrayNDT_double_1U_10U_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntAbsBandwidthCVND" "', argument " "1"" of type '" "npstat::AbsBandwidthCVND< int,npstat::ArrayND< double > > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCVND< int,npstat::ArrayND< double > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntAbsBandwidthCVND___call____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCVND< int,npstat::ArrayND< double > > arg1 = (npstat::AbsBandwidthCVND< int,npstat::ArrayND< double > > ) 0 ;
	npstat::HistoND< int > *arg2 = 0 ;
	npstat::ArrayND< double,1U,10U > *arg3 = 0 ;
	npstat::AbsPolyFilterND *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:IntAbsBandwidthCVND___call__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCVNDT_int_npstat__ArrayNDT_double_1U_10U_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntAbsBandwidthCVND___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCVND< int,npstat::ArrayND< double > > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCVND< int,npstat::ArrayND< double > > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_int_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< int > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< int > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< int > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntAbsBandwidthCVND___call__" "', argument " "3"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntAbsBandwidthCVND___call__" "', argument " "3"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	arg3 = reinterpret_cast< npstat::ArrayND< double,1U,10U > * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__AbsPolyFilterND, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IntAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	arg4 = reinterpret_cast< npstat::AbsPolyFilterND * >(argp4);
	{
	try {
	result = (double)((npstat::AbsBandwidthCVND< int,npstat::ArrayND< double > > const )arg1)->operator ()((npstat::HistoND< int > const &)arg2,(npstat::ArrayND< double,1U,10U > const &)arg3,(npstat::AbsPolyFilterND const &)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntAbsBandwidthCVND___call____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCVND< int,npstat::ArrayND< double > > arg1 = (npstat::AbsBandwidthCVND< int,npstat::ArrayND< double > > ) 0 ;
	npstat::HistoND< int > *arg2 = 0 ;
	double arg3 ;
	npstat::ArrayND< double,1U,10U > *arg4 = 0 ;
	npstat::AbsPolyFilterND *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:IntAbsBandwidthCVND___call__",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCVNDT_int_npstat__ArrayNDT_double_1U_10U_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntAbsBandwidthCVND___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCVND< int,npstat::ArrayND< double > > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCVND< int,npstat::ArrayND< double > > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_int_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< int > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< int > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< int > * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntAbsBandwidthCVND___call__" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IntAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	arg4 = reinterpret_cast< npstat::ArrayND< double,1U,10U > * >(argp4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__AbsPolyFilterND, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IntAbsBandwidthCVND___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntAbsBandwidthCVND___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	arg5 = reinterpret_cast< npstat::AbsPolyFilterND * >(argp5);
	{
	try {
	result = (double)((npstat::AbsBandwidthCVND< int,npstat::ArrayND< double > > const )arg1)->operator ()((npstat::HistoND< int > const &)arg2,arg3,(npstat::ArrayND< double,1U,10U > const &)arg4,(npstat::AbsPolyFilterND const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntAbsBandwidthCVND___call__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCVNDT_int_npstat__ArrayNDT_double_1U_10U_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__AbsPolyFilterND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_IntAbsBandwidthCVND___call____SWIG_0(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCVNDT_int_npstat__ArrayNDT_double_1U_10U_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__AbsPolyFilterND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_IntAbsBandwidthCVND___call____SWIG_1(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'IntAbsBandwidthCVND___call__'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::AbsBandwidthCVND< int,npstat::ArrayND< double > >::operator ()(npstat::HistoND< int > const &,npstat::ArrayND< double,1U,10U > const &,npstat::AbsPolyFilterND const &) const\n"
	" npstat::AbsBandwidthCVND< int,npstat::ArrayND< double > >::operator ()(npstat::HistoND< int > const &,double,npstat::ArrayND< double,1U,10U > const &,npstat::AbsPolyFilterND const &) const\n");
	return 0;
	}


	SWIGINTERN PyObject IntAbsBandwidthCVND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsBandwidthCVNDT_int_npstat__ArrayNDT_double_1U_10U_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_LLongAbsBandwidthCVND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCVND< long long,npstat::ArrayND< double > > arg1 = (npstat::AbsBandwidthCVND< long long,npstat::ArrayND< double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LLongAbsBandwidthCVND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCVNDT_long_long_npstat__ArrayNDT_double_1U_10U_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LLongAbsBandwidthCVND" "', argument " "1"" of type '" "npstat::AbsBandwidthCVND< long long,npstat::ArrayND< double > > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCVND< long long,npstat::ArrayND< double > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongAbsBandwidthCVND___call____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCVND< long long,npstat::ArrayND< double > > arg1 = (npstat::AbsBandwidthCVND< long long,npstat::ArrayND< double > > ) 0 ;
	npstat::HistoND< long long > *arg2 = 0 ;
	npstat::ArrayND< double,1U,10U > *arg3 = 0 ;
	npstat::AbsPolyFilterND *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:LLongAbsBandwidthCVND___call__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCVNDT_long_long_npstat__ArrayNDT_double_1U_10U_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongAbsBandwidthCVND___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCVND< long long,npstat::ArrayND< double > > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCVND< long long,npstat::ArrayND< double > > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LLongAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< long long > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LLongAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< long long > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< long long > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LLongAbsBandwidthCVND___call__" "', argument " "3"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LLongAbsBandwidthCVND___call__" "', argument " "3"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	arg3 = reinterpret_cast< npstat::ArrayND< double,1U,10U > * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__AbsPolyFilterND, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LLongAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LLongAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	arg4 = reinterpret_cast< npstat::AbsPolyFilterND * >(argp4);
	{
	try {
	result = (double)((npstat::AbsBandwidthCVND< long long,npstat::ArrayND< double > > const )arg1)->operator ()((npstat::HistoND< long long > const &)arg2,(npstat::ArrayND< double,1U,10U > const &)arg3,(npstat::AbsPolyFilterND const &)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongAbsBandwidthCVND___call____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCVND< long long,npstat::ArrayND< double > > arg1 = (npstat::AbsBandwidthCVND< long long,npstat::ArrayND< double > > ) 0 ;
	npstat::HistoND< long long > *arg2 = 0 ;
	double arg3 ;
	npstat::ArrayND< double,1U,10U > *arg4 = 0 ;
	npstat::AbsPolyFilterND *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:LLongAbsBandwidthCVND___call__",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCVNDT_long_long_npstat__ArrayNDT_double_1U_10U_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongAbsBandwidthCVND___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCVND< long long,npstat::ArrayND< double > > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCVND< long long,npstat::ArrayND< double > > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LLongAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< long long > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LLongAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< long long > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< long long > * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LLongAbsBandwidthCVND___call__" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LLongAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LLongAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	arg4 = reinterpret_cast< npstat::ArrayND< double,1U,10U > * >(argp4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__AbsPolyFilterND, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "LLongAbsBandwidthCVND___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LLongAbsBandwidthCVND___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	arg5 = reinterpret_cast< npstat::AbsPolyFilterND * >(argp5);
	{
	try {
	result = (double)((npstat::AbsBandwidthCVND< long long,npstat::ArrayND< double > > const )arg1)->operator ()((npstat::HistoND< long long > const &)arg2,arg3,(npstat::ArrayND< double,1U,10U > const &)arg4,(npstat::AbsPolyFilterND const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongAbsBandwidthCVND___call__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCVNDT_long_long_npstat__ArrayNDT_double_1U_10U_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__AbsPolyFilterND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_LLongAbsBandwidthCVND___call____SWIG_0(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCVNDT_long_long_npstat__ArrayNDT_double_1U_10U_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__AbsPolyFilterND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_LLongAbsBandwidthCVND___call____SWIG_1(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'LLongAbsBandwidthCVND___call__'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::AbsBandwidthCVND< long long,npstat::ArrayND< double > >::operator ()(npstat::HistoND< long long > const &,npstat::ArrayND< double,1U,10U > const &,npstat::AbsPolyFilterND const &) const\n"
	" npstat::AbsBandwidthCVND< long long,npstat::ArrayND< double > >::operator ()(npstat::HistoND< long long > const &,double,npstat::ArrayND< double,1U,10U > const &,npstat::AbsPolyFilterND const &) const\n");
	return 0;
	}


	SWIGINTERN PyObject LLongAbsBandwidthCVND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsBandwidthCVNDT_long_long_npstat__ArrayNDT_double_1U_10U_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_FloatAbsBandwidthCVND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCVND< float,npstat::ArrayND< double > > arg1 = (npstat::AbsBandwidthCVND< float,npstat::ArrayND< double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatAbsBandwidthCVND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCVNDT_float_npstat__ArrayNDT_double_1U_10U_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatAbsBandwidthCVND" "', argument " "1"" of type '" "npstat::AbsBandwidthCVND< float,npstat::ArrayND< double > > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCVND< float,npstat::ArrayND< double > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatAbsBandwidthCVND___call____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCVND< float,npstat::ArrayND< double > > arg1 = (npstat::AbsBandwidthCVND< float,npstat::ArrayND< double > > ) 0 ;
	npstat::HistoND< float > *arg2 = 0 ;
	npstat::ArrayND< double,1U,10U > *arg3 = 0 ;
	npstat::AbsPolyFilterND *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:FloatAbsBandwidthCVND___call__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCVNDT_float_npstat__ArrayNDT_double_1U_10U_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatAbsBandwidthCVND___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCVND< float,npstat::ArrayND< double > > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCVND< float,npstat::ArrayND< double > > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_float_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< float > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< float > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< float > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FloatAbsBandwidthCVND___call__" "', argument " "3"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatAbsBandwidthCVND___call__" "', argument " "3"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	arg3 = reinterpret_cast< npstat::ArrayND< double,1U,10U > * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__AbsPolyFilterND, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FloatAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	arg4 = reinterpret_cast< npstat::AbsPolyFilterND * >(argp4);
	{
	try {
	result = (double)((npstat::AbsBandwidthCVND< float,npstat::ArrayND< double > > const )arg1)->operator ()((npstat::HistoND< float > const &)arg2,(npstat::ArrayND< double,1U,10U > const &)arg3,(npstat::AbsPolyFilterND const &)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatAbsBandwidthCVND___call____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCVND< float,npstat::ArrayND< double > > arg1 = (npstat::AbsBandwidthCVND< float,npstat::ArrayND< double > > ) 0 ;
	npstat::HistoND< float > *arg2 = 0 ;
	double arg3 ;
	npstat::ArrayND< double,1U,10U > *arg4 = 0 ;
	npstat::AbsPolyFilterND *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:FloatAbsBandwidthCVND___call__",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCVNDT_float_npstat__ArrayNDT_double_1U_10U_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatAbsBandwidthCVND___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCVND< float,npstat::ArrayND< double > > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCVND< float,npstat::ArrayND< double > > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_float_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< float > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< float > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< float > * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatAbsBandwidthCVND___call__" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FloatAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	arg4 = reinterpret_cast< npstat::ArrayND< double,1U,10U > * >(argp4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__AbsPolyFilterND, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FloatAbsBandwidthCVND___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatAbsBandwidthCVND___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	arg5 = reinterpret_cast< npstat::AbsPolyFilterND * >(argp5);
	{
	try {
	result = (double)((npstat::AbsBandwidthCVND< float,npstat::ArrayND< double > > const )arg1)->operator ()((npstat::HistoND< float > const &)arg2,arg3,(npstat::ArrayND< double,1U,10U > const &)arg4,(npstat::AbsPolyFilterND const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatAbsBandwidthCVND___call__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCVNDT_float_npstat__ArrayNDT_double_1U_10U_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__AbsPolyFilterND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatAbsBandwidthCVND___call____SWIG_0(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCVNDT_float_npstat__ArrayNDT_double_1U_10U_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__AbsPolyFilterND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatAbsBandwidthCVND___call____SWIG_1(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatAbsBandwidthCVND___call__'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::AbsBandwidthCVND< float,npstat::ArrayND< double > >::operator ()(npstat::HistoND< float > const &,npstat::ArrayND< double,1U,10U > const &,npstat::AbsPolyFilterND const &) const\n"
	" npstat::AbsBandwidthCVND< float,npstat::ArrayND< double > >::operator ()(npstat::HistoND< float > const &,double,npstat::ArrayND< double,1U,10U > const &,npstat::AbsPolyFilterND const &) const\n");
	return 0;
	}


	SWIGINTERN PyObject FloatAbsBandwidthCVND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsBandwidthCVNDT_float_npstat__ArrayNDT_double_1U_10U_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_DoubleAbsBandwidthCVND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCVND< double,npstat::ArrayND< double > > arg1 = (npstat::AbsBandwidthCVND< double,npstat::ArrayND< double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleAbsBandwidthCVND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCVNDT_double_npstat__ArrayNDT_double_1U_10U_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleAbsBandwidthCVND" "', argument " "1"" of type '" "npstat::AbsBandwidthCVND< double,npstat::ArrayND< double > > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCVND< double,npstat::ArrayND< double > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleAbsBandwidthCVND___call____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCVND< double,npstat::ArrayND< double > > arg1 = (npstat::AbsBandwidthCVND< double,npstat::ArrayND< double > > ) 0 ;
	npstat::HistoND< double > *arg2 = 0 ;
	npstat::ArrayND< double,1U,10U > *arg3 = 0 ;
	npstat::AbsPolyFilterND *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:DoubleAbsBandwidthCVND___call__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCVNDT_double_npstat__ArrayNDT_double_1U_10U_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleAbsBandwidthCVND___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCVND< double,npstat::ArrayND< double > > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCVND< double,npstat::ArrayND< double > > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< double > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleAbsBandwidthCVND___call__" "', argument " "3"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleAbsBandwidthCVND___call__" "', argument " "3"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	arg3 = reinterpret_cast< npstat::ArrayND< double,1U,10U > * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__AbsPolyFilterND, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DoubleAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	arg4 = reinterpret_cast< npstat::AbsPolyFilterND * >(argp4);
	{
	try {
	result = (double)((npstat::AbsBandwidthCVND< double,npstat::ArrayND< double > > const )arg1)->operator ()((npstat::HistoND< double > const &)arg2,(npstat::ArrayND< double,1U,10U > const &)arg3,(npstat::AbsPolyFilterND const &)arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleAbsBandwidthCVND___call____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBandwidthCVND< double,npstat::ArrayND< double > > arg1 = (npstat::AbsBandwidthCVND< double,npstat::ArrayND< double > > ) 0 ;
	npstat::HistoND< double > *arg2 = 0 ;
	double arg3 ;
	npstat::ArrayND< double,1U,10U > *arg4 = 0 ;
	npstat::AbsPolyFilterND *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:DoubleAbsBandwidthCVND___call__",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBandwidthCVNDT_double_npstat__ArrayNDT_double_1U_10U_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleAbsBandwidthCVND___call__" "', argument " "1"" of type '" "npstat::AbsBandwidthCVND< double,npstat::ArrayND< double > > const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBandwidthCVND< double,npstat::ArrayND< double > > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleAbsBandwidthCVND___call__" "', argument " "2"" of type '" "npstat::HistoND< double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< double > * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleAbsBandwidthCVND___call__" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DoubleAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleAbsBandwidthCVND___call__" "', argument " "4"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	arg4 = reinterpret_cast< npstat::ArrayND< double,1U,10U > * >(argp4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__AbsPolyFilterND, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DoubleAbsBandwidthCVND___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleAbsBandwidthCVND___call__" "', argument " "5"" of type '" "npstat::AbsPolyFilterND const &""'");
	}
	arg5 = reinterpret_cast< npstat::AbsPolyFilterND * >(argp5);
	{
	try {
	result = (double)((npstat::AbsBandwidthCVND< double,npstat::ArrayND< double > > const )arg1)->operator ()((npstat::HistoND< double > const &)arg2,arg3,(npstat::ArrayND< double,1U,10U > const &)arg4,(npstat::AbsPolyFilterND const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleAbsBandwidthCVND___call__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCVNDT_double_npstat__ArrayNDT_double_1U_10U_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__AbsPolyFilterND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleAbsBandwidthCVND___call____SWIG_0(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsBandwidthCVNDT_double_npstat__ArrayNDT_double_1U_10U_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__AbsPolyFilterND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleAbsBandwidthCVND___call____SWIG_1(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleAbsBandwidthCVND___call__'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::AbsBandwidthCVND< double,npstat::ArrayND< double > >::operator ()(npstat::HistoND< double > const &,npstat::ArrayND< double,1U,10U > const &,npstat::AbsPolyFilterND const &) const\n"
	" npstat::AbsBandwidthCVND< double,npstat::ArrayND< double > >::operator ()(npstat::HistoND< double > const &,double,npstat::ArrayND< double,1U,10U > const &,npstat::AbsPolyFilterND const &) const\n");
	return 0;
	}


	SWIGINTERN PyObject DoubleAbsBandwidthCVND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsBandwidthCVNDT_double_npstat__ArrayNDT_double_1U_10U_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_ConstantBandwidthSmootherND_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmootherND< 4U > arg1 = (npstat::ConstantBandwidthSmootherND< 4U > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ConstantBandwidthSmootherND_4",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmootherND< 4U > *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmootherND< 4U > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmootherND_4_dim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmootherND< 4U > arg1 = (npstat::ConstantBandwidthSmootherND< 4U > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:ConstantBandwidthSmootherND_4_dim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmootherND_4_dim" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmootherND< 4U > const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmootherND< 4U > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::ConstantBandwidthSmootherND< 4U > const *)arg1)->dim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmootherND_4_shape(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmootherND< 4U > arg1 = (npstat::ConstantBandwidthSmootherND< 4U > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayShape *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:ConstantBandwidthSmootherND_4_shape",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmootherND_4_shape" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmootherND< 4U > const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmootherND< 4U > * >(argp1);
	{
	try {
	result = (npstat::ArrayShape ) &((npstat::ConstantBandwidthSmootherND< 4U > const )arg1)->shape();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmootherND_4_shapeData(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmootherND< 4U > arg1 = (npstat::ConstantBandwidthSmootherND< 4U > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:ConstantBandwidthSmootherND_4_shapeData",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmootherND_4_shapeData" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmootherND< 4U > const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmootherND< 4U > * >(argp1);
	{
	try {
	result = (unsigned int )((npstat::ConstantBandwidthSmootherND< 4U > const )arg1)->shapeData();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmootherND_4_maxDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmootherND< 4U > arg1 = (npstat::ConstantBandwidthSmootherND< 4U > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:ConstantBandwidthSmootherND_4_maxDegree",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmootherND_4_maxDegree" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmootherND< 4U > const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmootherND< 4U > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::ConstantBandwidthSmootherND< 4U > const *)arg1)->maxDegree();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmootherND_4_mirrorsData(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmootherND< 4U > arg1 = (npstat::ConstantBandwidthSmootherND< 4U > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:ConstantBandwidthSmootherND_4_mirrorsData",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmootherND_4_mirrorsData" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmootherND< 4U > const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmootherND< 4U > * >(argp1);
	{
	try {
	result = (bool)((npstat::ConstantBandwidthSmootherND< 4U > const *)arg1)->mirrorsData();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmootherND_4_taper(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmootherND< 4U > arg1 = (npstat::ConstantBandwidthSmootherND< 4U > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:ConstantBandwidthSmootherND_4_taper",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmootherND_4_taper" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmootherND< 4U > const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmootherND< 4U > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstantBandwidthSmootherND_4_taper" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (double)((npstat::ConstantBandwidthSmootherND< 4U > const *)arg1)->taper(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConstantBandwidthSmootherND_4__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char > *arg1 = 0 ;
	npstat::AbsDistributionND *arg2 = 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	bool arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	npstat::ConstantBandwidthSmootherND< 4U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ConstantBandwidthSmootherND_4",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistributionND * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	{
	try {
	result = (npstat::ConstantBandwidthSmootherND< 4U > )new npstat::ConstantBandwidthSmootherND< 4U >((npstat::HistoND< unsigned char > const &)arg1,(npstat::AbsDistributionND const &)arg2,(double const )arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConstantBandwidthSmootherND_4__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char > *arg1 = 0 ;
	npstat::AbsDistributionND *arg2 = 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::ConstantBandwidthSmootherND< 4U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ConstantBandwidthSmootherND_4",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistributionND * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	result = (npstat::ConstantBandwidthSmootherND< 4U > )new npstat::ConstantBandwidthSmootherND< 4U >((npstat::HistoND< unsigned char > const &)arg1,(npstat::AbsDistributionND const &)arg2,(double const )arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConstantBandwidthSmootherND_4__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int > *arg1 = 0 ;
	npstat::AbsDistributionND *arg2 = 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	bool arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	npstat::ConstantBandwidthSmootherND< 4U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ConstantBandwidthSmootherND_4",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< int > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< int > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistributionND * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	{
	try {
	result = (npstat::ConstantBandwidthSmootherND< 4U > )new npstat::ConstantBandwidthSmootherND< 4U >((npstat::HistoND< int > const &)arg1,(npstat::AbsDistributionND const &)arg2,(double const )arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConstantBandwidthSmootherND_4__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int > *arg1 = 0 ;
	npstat::AbsDistributionND *arg2 = 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::ConstantBandwidthSmootherND< 4U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ConstantBandwidthSmootherND_4",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< int > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< int > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistributionND * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	result = (npstat::ConstantBandwidthSmootherND< 4U > )new npstat::ConstantBandwidthSmootherND< 4U >((npstat::HistoND< int > const &)arg1,(npstat::AbsDistributionND const &)arg2,(double const )arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConstantBandwidthSmootherND_4__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long > *arg1 = 0 ;
	npstat::AbsDistributionND *arg2 = 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	bool arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	npstat::ConstantBandwidthSmootherND< 4U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ConstantBandwidthSmootherND_4",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< long long > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< long long > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistributionND * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	{
	try {
	result = (npstat::ConstantBandwidthSmootherND< 4U > )new npstat::ConstantBandwidthSmootherND< 4U >((npstat::HistoND< long long > const &)arg1,(npstat::AbsDistributionND const &)arg2,(double const )arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConstantBandwidthSmootherND_4__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long > *arg1 = 0 ;
	npstat::AbsDistributionND *arg2 = 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::ConstantBandwidthSmootherND< 4U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ConstantBandwidthSmootherND_4",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< long long > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< long long > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistributionND * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	result = (npstat::ConstantBandwidthSmootherND< 4U > )new npstat::ConstantBandwidthSmootherND< 4U >((npstat::HistoND< long long > const &)arg1,(npstat::AbsDistributionND const &)arg2,(double const )arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConstantBandwidthSmootherND_4__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float > *arg1 = 0 ;
	npstat::AbsDistributionND *arg2 = 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	bool arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	npstat::ConstantBandwidthSmootherND< 4U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ConstantBandwidthSmootherND_4",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< float > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< float > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistributionND * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	{
	try {
	result = (npstat::ConstantBandwidthSmootherND< 4U > )new npstat::ConstantBandwidthSmootherND< 4U >((npstat::HistoND< float > const &)arg1,(npstat::AbsDistributionND const &)arg2,(double const )arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConstantBandwidthSmootherND_4__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float > *arg1 = 0 ;
	npstat::AbsDistributionND *arg2 = 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::ConstantBandwidthSmootherND< 4U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ConstantBandwidthSmootherND_4",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< float > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< float > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistributionND * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	result = (npstat::ConstantBandwidthSmootherND< 4U > )new npstat::ConstantBandwidthSmootherND< 4U >((npstat::HistoND< float > const &)arg1,(npstat::AbsDistributionND const &)arg2,(double const )arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConstantBandwidthSmootherND_4__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double > *arg1 = 0 ;
	npstat::AbsDistributionND *arg2 = 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	bool arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	npstat::ConstantBandwidthSmootherND< 4U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ConstantBandwidthSmootherND_4",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< double > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< double > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistributionND * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	{
	try {
	result = (npstat::ConstantBandwidthSmootherND< 4U > )new npstat::ConstantBandwidthSmootherND< 4U >((npstat::HistoND< double > const &)arg1,(npstat::AbsDistributionND const &)arg2,(double const )arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConstantBandwidthSmootherND_4__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double > *arg1 = 0 ;
	npstat::AbsDistributionND *arg2 = 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::ConstantBandwidthSmootherND< 4U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ConstantBandwidthSmootherND_4",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< double > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "1"" of type '" "npstat::HistoND< double > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "2"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistributionND * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantBandwidthSmootherND_4" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	result = (npstat::ConstantBandwidthSmootherND< 4U > )new npstat::ConstantBandwidthSmootherND< 4U >((npstat::HistoND< double > const &)arg1,(npstat::AbsDistributionND const &)arg2,(double const )arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConstantBandwidthSmootherND_4(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConstantBandwidthSmootherND_4__SWIG_1(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConstantBandwidthSmootherND_4__SWIG_3(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConstantBandwidthSmootherND_4__SWIG_5(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConstantBandwidthSmootherND_4__SWIG_7(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConstantBandwidthSmootherND_4__SWIG_9(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConstantBandwidthSmootherND_4__SWIG_2(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConstantBandwidthSmootherND_4__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConstantBandwidthSmootherND_4__SWIG_0(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConstantBandwidthSmootherND_4__SWIG_8(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConstantBandwidthSmootherND_4__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ConstantBandwidthSmootherND_4'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::ConstantBandwidthSmootherND(npstat::HistoND< unsigned char > const &,npstat::AbsDistributionND const &,double const *,unsigned int,bool)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::ConstantBandwidthSmootherND(npstat::HistoND< unsigned char > const &,npstat::AbsDistributionND const &,double const *,unsigned int)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::ConstantBandwidthSmootherND(npstat::HistoND< int > const &,npstat::AbsDistributionND const &,double const *,unsigned int,bool)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::ConstantBandwidthSmootherND(npstat::HistoND< int > const &,npstat::AbsDistributionND const &,double const *,unsigned int)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::ConstantBandwidthSmootherND(npstat::HistoND< long long > const &,npstat::AbsDistributionND const &,double const *,unsigned int,bool)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::ConstantBandwidthSmootherND(npstat::HistoND< long long > const &,npstat::AbsDistributionND const &,double const *,unsigned int)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::ConstantBandwidthSmootherND(npstat::HistoND< float > const &,npstat::AbsDistributionND const &,double const *,unsigned int,bool)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::ConstantBandwidthSmootherND(npstat::HistoND< float > const &,npstat::AbsDistributionND const &,double const *,unsigned int)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::ConstantBandwidthSmootherND(npstat::HistoND< double > const &,npstat::AbsDistributionND const &,double const *,unsigned int,bool)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::ConstantBandwidthSmootherND(npstat::HistoND< double > const &,npstat::AbsDistributionND const &,double const *,unsigned int)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmootherND< 4U > arg1 = (npstat::ConstantBandwidthSmootherND< 4U > ) 0 ;
	npstat::HistoND< int > *arg2 = 0 ;
	npstat::HistoND< double > arg3 = (npstat::HistoND< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ConstantBandwidthSmootherND_4_smoothHistogram",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmootherND< 4U > *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmootherND< 4U > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_int_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< int > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< int > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< int > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__HistoNDT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "3"" of type '" "npstat::HistoND< double > *""'");
	}
	arg3 = reinterpret_cast< npstat::HistoND< double > * >(argp3);
	{
	try {
	(arg1)->SWIGTEMPLATEDISAMBIGUATOR smoothHistogram< int,double >((npstat::HistoND< int > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmootherND< 4U > arg1 = (npstat::ConstantBandwidthSmootherND< 4U > ) 0 ;
	npstat::HistoND< long long > *arg2 = 0 ;
	npstat::HistoND< double > arg3 = (npstat::HistoND< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ConstantBandwidthSmootherND_4_smoothHistogram",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmootherND< 4U > *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmootherND< 4U > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< long long > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< long long > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< long long > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__HistoNDT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "3"" of type '" "npstat::HistoND< double > *""'");
	}
	arg3 = reinterpret_cast< npstat::HistoND< double > * >(argp3);
	{
	try {
	(arg1)->SWIGTEMPLATEDISAMBIGUATOR smoothHistogram< long long,double >((npstat::HistoND< long long > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmootherND< 4U > arg1 = (npstat::ConstantBandwidthSmootherND< 4U > ) 0 ;
	npstat::HistoND< float > *arg2 = 0 ;
	npstat::HistoND< double > arg3 = (npstat::HistoND< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ConstantBandwidthSmootherND_4_smoothHistogram",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmootherND< 4U > *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmootherND< 4U > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_float_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< float > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< float > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< float > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__HistoNDT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "3"" of type '" "npstat::HistoND< double > *""'");
	}
	arg3 = reinterpret_cast< npstat::HistoND< double > * >(argp3);
	{
	try {
	(arg1)->SWIGTEMPLATEDISAMBIGUATOR smoothHistogram< float,double >((npstat::HistoND< float > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmootherND< 4U > arg1 = (npstat::ConstantBandwidthSmootherND< 4U > ) 0 ;
	npstat::HistoND< double > *arg2 = 0 ;
	npstat::HistoND< double > arg3 = (npstat::HistoND< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ConstantBandwidthSmootherND_4_smoothHistogram",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmootherND< 4U > *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmootherND< 4U > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< double > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__HistoNDT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "3"" of type '" "npstat::HistoND< double > *""'");
	}
	arg3 = reinterpret_cast< npstat::HistoND< double > * >(argp3);
	{
	try {
	(arg1)->SWIGTEMPLATEDISAMBIGUATOR smoothHistogram< double,double >((npstat::HistoND< double > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmootherND< 4U > arg1 = (npstat::ConstantBandwidthSmootherND< 4U > ) 0 ;
	npstat::HistoND< unsigned char > *arg2 = 0 ;
	npstat::HistoND< double > arg3 = (npstat::HistoND< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ConstantBandwidthSmootherND_4_smoothHistogram",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmootherND< 4U > *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmootherND< 4U > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< unsigned char > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__HistoNDT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "3"" of type '" "npstat::HistoND< double > *""'");
	}
	arg3 = reinterpret_cast< npstat::HistoND< double > * >(argp3);
	{
	try {
	(arg1)->SWIGTEMPLATEDISAMBIGUATOR smoothHistogram< unsigned char,double >((npstat::HistoND< unsigned char > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmootherND< 4U > arg1 = (npstat::ConstantBandwidthSmootherND< 4U > ) 0 ;
	npstat::HistoND< int > *arg2 = 0 ;
	npstat::HistoND< float > arg3 = (npstat::HistoND< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ConstantBandwidthSmootherND_4_smoothHistogram",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmootherND< 4U > *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmootherND< 4U > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_int_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< int > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< int > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< int > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__HistoNDT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "3"" of type '" "npstat::HistoND< float > *""'");
	}
	arg3 = reinterpret_cast< npstat::HistoND< float > * >(argp3);
	{
	try {
	(arg1)->SWIGTEMPLATEDISAMBIGUATOR smoothHistogram< int,float >((npstat::HistoND< int > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmootherND< 4U > arg1 = (npstat::ConstantBandwidthSmootherND< 4U > ) 0 ;
	npstat::HistoND< long long > *arg2 = 0 ;
	npstat::HistoND< float > arg3 = (npstat::HistoND< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ConstantBandwidthSmootherND_4_smoothHistogram",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmootherND< 4U > *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmootherND< 4U > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< long long > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< long long > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< long long > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__HistoNDT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "3"" of type '" "npstat::HistoND< float > *""'");
	}
	arg3 = reinterpret_cast< npstat::HistoND< float > * >(argp3);
	{
	try {
	(arg1)->SWIGTEMPLATEDISAMBIGUATOR smoothHistogram< long long,float >((npstat::HistoND< long long > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmootherND< 4U > arg1 = (npstat::ConstantBandwidthSmootherND< 4U > ) 0 ;
	npstat::HistoND< float > *arg2 = 0 ;
	npstat::HistoND< float > arg3 = (npstat::HistoND< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ConstantBandwidthSmootherND_4_smoothHistogram",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmootherND< 4U > *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmootherND< 4U > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_float_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< float > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< float > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< float > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__HistoNDT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "3"" of type '" "npstat::HistoND< float > *""'");
	}
	arg3 = reinterpret_cast< npstat::HistoND< float > * >(argp3);
	{
	try {
	(arg1)->SWIGTEMPLATEDISAMBIGUATOR smoothHistogram< float,float >((npstat::HistoND< float > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmootherND< 4U > arg1 = (npstat::ConstantBandwidthSmootherND< 4U > ) 0 ;
	npstat::HistoND< double > *arg2 = 0 ;
	npstat::HistoND< float > arg3 = (npstat::HistoND< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ConstantBandwidthSmootherND_4_smoothHistogram",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmootherND< 4U > *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmootherND< 4U > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< double > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__HistoNDT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "3"" of type '" "npstat::HistoND< float > *""'");
	}
	arg3 = reinterpret_cast< npstat::HistoND< float > * >(argp3);
	{
	try {
	(arg1)->SWIGTEMPLATEDISAMBIGUATOR smoothHistogram< double,float >((npstat::HistoND< double > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmootherND< 4U > arg1 = (npstat::ConstantBandwidthSmootherND< 4U > ) 0 ;
	npstat::HistoND< unsigned char > *arg2 = 0 ;
	npstat::HistoND< float > arg3 = (npstat::HistoND< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ConstantBandwidthSmootherND_4_smoothHistogram",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmootherND< 4U > *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmootherND< 4U > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "2"" of type '" "npstat::HistoND< unsigned char > const &""'");
	}
	arg2 = reinterpret_cast< npstat::HistoND< unsigned char > * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__HistoNDT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstantBandwidthSmootherND_4_smoothHistogram" "', argument " "3"" of type '" "npstat::HistoND< float > *""'");
	}
	arg3 = reinterpret_cast< npstat::HistoND< float > * >(argp3);
	{
	try {
	(arg1)->SWIGTEMPLATEDISAMBIGUATOR smoothHistogram< unsigned char,float >((npstat::HistoND< unsigned char > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmootherND_4_smoothHistogram(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_npstat__HistoNDT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_1(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_npstat__HistoNDT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_npstat__HistoNDT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_npstat__HistoNDT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_4(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_npstat__HistoNDT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_5(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_npstat__HistoNDT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_6(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_npstat__HistoNDT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_7(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_npstat__HistoNDT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_8(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_npstat__HistoNDT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_9(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_npstat__HistoNDT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ConstantBandwidthSmootherND_4_smoothHistogram__SWIG_10(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ConstantBandwidthSmootherND_4_smoothHistogram'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::smoothHistogram< int,double >(npstat::HistoND< int > const &,npstat::HistoND< double > *)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::smoothHistogram< long long,double >(npstat::HistoND< long long > const &,npstat::HistoND< double > *)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::smoothHistogram< float,double >(npstat::HistoND< float > const &,npstat::HistoND< double > *)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::smoothHistogram< double,double >(npstat::HistoND< double > const &,npstat::HistoND< double > *)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::smoothHistogram< unsigned char,double >(npstat::HistoND< unsigned char > const &,npstat::HistoND< double > *)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::smoothHistogram< int,float >(npstat::HistoND< int > const &,npstat::HistoND< float > *)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::smoothHistogram< long long,float >(npstat::HistoND< long long > const &,npstat::HistoND< float > *)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::smoothHistogram< float,float >(npstat::HistoND< float > const &,npstat::HistoND< float > *)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::smoothHistogram< double,float >(npstat::HistoND< double > const &,npstat::HistoND< float > *)\n"
	" npstat::ConstantBandwidthSmootherND< 4U >::smoothHistogram< unsigned char,float >(npstat::HistoND< unsigned char > const &,npstat::HistoND< float > *)\n");
	return 0;
	}


	SWIGINTERN PyObject ConstantBandwidthSmootherND_4_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ConstantBandwidthSmootherNDT_4U_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_RightCensoredDistribution__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistribution1D *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::RightCensoredDistribution *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_RightCensoredDistribution",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RightCensoredDistribution" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RightCensoredDistribution" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RightCensoredDistribution" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RightCensoredDistribution" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (npstat::RightCensoredDistribution )new npstat::RightCensoredDistribution((npstat::AbsDistribution1D const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__RightCensoredDistribution, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_RightCensoredDistribution__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RightCensoredDistribution *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::RightCensoredDistribution *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_RightCensoredDistribution",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__RightCensoredDistribution, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RightCensoredDistribution" "', argument " "1"" of type '" "npstat::RightCensoredDistribution const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RightCensoredDistribution" "', argument " "1"" of type '" "npstat::RightCensoredDistribution const &""'");
	}
	arg1 = reinterpret_cast< npstat::RightCensoredDistribution * >(argp1);
	{
	try {
	result = (npstat::RightCensoredDistribution )new npstat::RightCensoredDistribution((npstat::RightCensoredDistribution const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__RightCensoredDistribution, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_RightCensoredDistribution(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__RightCensoredDistribution, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_RightCensoredDistribution__SWIG_1(self, args);
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_RightCensoredDistribution__SWIG_0(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_RightCensoredDistribution'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::RightCensoredDistribution::RightCensoredDistribution(npstat::AbsDistribution1D const &,double,double)\n"
	" npstat::RightCensoredDistribution::RightCensoredDistribution(npstat::RightCensoredDistribution const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_RightCensoredDistribution_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RightCensoredDistribution arg1 = (npstat::RightCensoredDistribution ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::RightCensoredDistribution *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:RightCensoredDistribution_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RightCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RightCensoredDistribution_clone" "', argument " "1"" of type '" "npstat::RightCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::RightCensoredDistribution * >(argp1);
	{
	try {
	result = (npstat::RightCensoredDistribution )((npstat::RightCensoredDistribution const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__RightCensoredDistribution, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_RightCensoredDistribution(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RightCensoredDistribution arg1 = (npstat::RightCensoredDistribution ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_RightCensoredDistribution",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RightCensoredDistribution, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RightCensoredDistribution" "', argument " "1"" of type '" "npstat::RightCensoredDistribution *""'");
	}
	arg1 = reinterpret_cast< npstat::RightCensoredDistribution * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RightCensoredDistribution_visible(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RightCensoredDistribution arg1 = (npstat::RightCensoredDistribution ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::AbsDistribution1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:RightCensoredDistribution_visible",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RightCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RightCensoredDistribution_visible" "', argument " "1"" of type '" "npstat::RightCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::RightCensoredDistribution * >(argp1);
	{
	try {
	result = (npstat::AbsDistribution1D ) &((npstat::RightCensoredDistribution const )arg1)->visible();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RightCensoredDistribution_visibleFraction(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RightCensoredDistribution arg1 = (npstat::RightCensoredDistribution ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:RightCensoredDistribution_visibleFraction",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RightCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RightCensoredDistribution_visibleFraction" "', argument " "1"" of type '" "npstat::RightCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::RightCensoredDistribution * >(argp1);
	{
	try {
	result = (double)((npstat::RightCensoredDistribution const *)arg1)->visibleFraction();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RightCensoredDistribution_effectiveInfinity(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RightCensoredDistribution arg1 = (npstat::RightCensoredDistribution ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:RightCensoredDistribution_effectiveInfinity",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RightCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RightCensoredDistribution_effectiveInfinity" "', argument " "1"" of type '" "npstat::RightCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::RightCensoredDistribution * >(argp1);
	{
	try {
	result = (double)((npstat::RightCensoredDistribution const *)arg1)->effectiveInfinity();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RightCensoredDistribution_density(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RightCensoredDistribution arg1 = (npstat::RightCensoredDistribution ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:RightCensoredDistribution_density",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RightCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RightCensoredDistribution_density" "', argument " "1"" of type '" "npstat::RightCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::RightCensoredDistribution * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RightCensoredDistribution_density" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::RightCensoredDistribution const *)arg1)->density(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RightCensoredDistribution_cdf(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RightCensoredDistribution arg1 = (npstat::RightCensoredDistribution ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:RightCensoredDistribution_cdf",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RightCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RightCensoredDistribution_cdf" "', argument " "1"" of type '" "npstat::RightCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::RightCensoredDistribution * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RightCensoredDistribution_cdf" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::RightCensoredDistribution const *)arg1)->cdf(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RightCensoredDistribution_exceedance(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RightCensoredDistribution arg1 = (npstat::RightCensoredDistribution ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:RightCensoredDistribution_exceedance",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RightCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RightCensoredDistribution_exceedance" "', argument " "1"" of type '" "npstat::RightCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::RightCensoredDistribution * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RightCensoredDistribution_exceedance" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::RightCensoredDistribution const *)arg1)->exceedance(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RightCensoredDistribution_quantile(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RightCensoredDistribution arg1 = (npstat::RightCensoredDistribution ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:RightCensoredDistribution_quantile",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RightCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RightCensoredDistribution_quantile" "', argument " "1"" of type '" "npstat::RightCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::RightCensoredDistribution * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RightCensoredDistribution_quantile" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::RightCensoredDistribution const *)arg1)->quantile(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RightCensoredDistribution_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RightCensoredDistribution arg1 = (npstat::RightCensoredDistribution ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:RightCensoredDistribution_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RightCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RightCensoredDistribution_classId" "', argument " "1"" of type '" "npstat::RightCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::RightCensoredDistribution * >(argp1);
	{
	try {
	result = ((npstat::RightCensoredDistribution const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RightCensoredDistribution_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RightCensoredDistribution arg1 = (npstat::RightCensoredDistribution ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:RightCensoredDistribution_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RightCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RightCensoredDistribution_write" "', argument " "1"" of type '" "npstat::RightCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::RightCensoredDistribution * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RightCensoredDistribution_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RightCensoredDistribution_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::RightCensoredDistribution const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RightCensoredDistribution_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":RightCensoredDistribution_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::RightCensoredDistribution::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RightCensoredDistribution_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":RightCensoredDistribution_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::RightCensoredDistribution::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RightCensoredDistribution_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::RightCensoredDistribution *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:RightCensoredDistribution_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RightCensoredDistribution_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RightCensoredDistribution_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RightCensoredDistribution_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RightCensoredDistribution_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::RightCensoredDistribution )npstat::RightCensoredDistribution::read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__RightCensoredDistribution, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject RightCensoredDistribution_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__RightCensoredDistribution, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_amisePluginBwGauss__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	double arg2 ;
	double arg3 ;
	double arg4 = (double ) 0 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:amisePluginBwGauss",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "amisePluginBwGauss" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "amisePluginBwGauss" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "amisePluginBwGauss" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "amisePluginBwGauss" "', argument " "4"" of type '" "double *""'");
	}
	arg4 = reinterpret_cast< double * >(argp4);
	{
	try {
	result = (double)npstat::amisePluginBwGauss(arg1,arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_amisePluginBwGauss__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	double arg2 ;
	double arg3 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:amisePluginBwGauss",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "amisePluginBwGauss" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "amisePluginBwGauss" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "amisePluginBwGauss" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (double)npstat::amisePluginBwGauss(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_amisePluginBwGauss(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_amisePluginBwGauss__SWIG_1(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_amisePluginBwGauss__SWIG_0(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'amisePluginBwGauss'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::amisePluginBwGauss(unsigned int,double,double,double *)\n"
	" npstat::amisePluginBwGauss(unsigned int,double,double)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_approxAmisePluginBwGauss(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	double arg3 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:approxAmisePluginBwGauss",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "approxAmisePluginBwGauss" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "approxAmisePluginBwGauss" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "approxAmisePluginBwGauss" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (double)npstat::approxAmisePluginBwGauss(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_amisePluginBwSymbeta__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 = (double ) 0 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:amisePluginBwSymbeta",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "amisePluginBwSymbeta" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "amisePluginBwSymbeta" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "amisePluginBwSymbeta" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "amisePluginBwSymbeta" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "amisePluginBwSymbeta" "', argument " "5"" of type '" "double *""'");
	}
	arg5 = reinterpret_cast< double * >(argp5);
	{
	try {
	result = (double)npstat::amisePluginBwSymbeta(arg1,arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_amisePluginBwSymbeta__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int arg2 ;
	double arg3 ;
	double arg4 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:amisePluginBwSymbeta",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "amisePluginBwSymbeta" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "amisePluginBwSymbeta" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "amisePluginBwSymbeta" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "amisePluginBwSymbeta" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	result = (double)npstat::amisePluginBwSymbeta(arg1,arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_amisePluginBwSymbeta(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 4) {
	int _v;
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_amisePluginBwSymbeta__SWIG_1(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_amisePluginBwSymbeta__SWIG_0(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'amisePluginBwSymbeta'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::amisePluginBwSymbeta(unsigned int,unsigned int,double,double,double *)\n"
	" npstat::amisePluginBwSymbeta(unsigned int,unsigned int,double,double)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_symbetaBandwidthRatio(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int arg1 ;
	unsigned int arg2 ;
	int val1 ;
	int ecode1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:symbetaBandwidthRatio",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "symbetaBandwidthRatio" "', argument " "1"" of type '" "int""'");
	}
	arg1 = static_cast< int >(val1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbetaBandwidthRatio" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (double)npstat::symbetaBandwidthRatio(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_approxSymbetaBandwidthRatio(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int arg1 ;
	double arg2 ;
	int val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:approxSymbetaBandwidthRatio",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "approxSymbetaBandwidthRatio" "', argument " "1"" of type '" "int""'");
	}
	arg1 = static_cast< int >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "approxSymbetaBandwidthRatio" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)npstat::approxSymbetaBandwidthRatio(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_amisePluginDegreeGauss(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:amisePluginDegreeGauss",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "amisePluginDegreeGauss" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	{
	try {
	result = (unsigned int)npstat::amisePluginDegreeGauss(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_amisePluginDegreeSymbeta(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	double arg2 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"OO:amisePluginDegreeSymbeta",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "amisePluginDegreeSymbeta" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "amisePluginDegreeSymbeta" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (unsigned int)npstat::amisePluginDegreeSymbeta(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_maxFilterDegreeSupported(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":maxFilterDegreeSupported")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::maxFilterDegreeSupported();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_integralOfSymmetricBetaSquared__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int arg1 ;
	int val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:integralOfSymmetricBetaSquared",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "integralOfSymmetricBetaSquared" "', argument " "1"" of type '" "int""'");
	}
	arg1 = static_cast< int >(val1);
	{
	try {
	result = (double)npstat::integralOfSymmetricBetaSquared(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_integralOfSymmetricBetaSquared__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int arg1 ;
	double arg2 ;
	double arg3 ;
	int val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:integralOfSymmetricBetaSquared",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "integralOfSymmetricBetaSquared" "', argument " "1"" of type '" "int""'");
	}
	arg1 = static_cast< int >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "integralOfSymmetricBetaSquared" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "integralOfSymmetricBetaSquared" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (double)npstat::integralOfSymmetricBetaSquared(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_integralOfSymmetricBetaSquared(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	{
	int res = SWIG_AsVal_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_integralOfSymmetricBetaSquared__SWIG_0(self, args);
	}
	}
	if (argc == 3) {
	int _v;
	{
	int res = SWIG_AsVal_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_integralOfSymmetricBetaSquared__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'integralOfSymmetricBetaSquared'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::integralOfSymmetricBetaSquared(int)\n"
	" npstat::integralOfSymmetricBetaSquared(int,double,double)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_new_GaussianMixture1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	npstat::GaussianMixtureEntry arg3 = (npstat::GaussianMixtureEntry ) 0 ;
	unsigned int arg4 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::GaussianMixture1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_GaussianMixture1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussianMixture1D" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GaussianMixture1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianMixture1D" "', argument " "3"" of type '" "npstat::GaussianMixtureEntry const *""'");
	}
	arg3 = reinterpret_cast< npstat::GaussianMixtureEntry * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GaussianMixture1D" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	result = (npstat::GaussianMixture1D )new npstat::GaussianMixture1D(arg1,arg2,(npstat::GaussianMixtureEntry const )arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__GaussianMixture1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_GaussianMixture1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > *arg3 = 0 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int res3 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::GaussianMixture1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_GaussianMixture1D",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussianMixture1D" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GaussianMixture1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > ptr = (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > )0;
	res3 = swig::asptr(obj2, &ptr);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GaussianMixture1D" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianMixture1D" "', argument " "3"" of type '" "std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > const &""'");
	}
	arg3 = ptr;
	}
	{
	try {
	result = (npstat::GaussianMixture1D )new npstat::GaussianMixture1D(arg1,arg2,(std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__GaussianMixture1D, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res3)) delete arg3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res3)) delete arg3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_GaussianMixture1D__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Gauss1D *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::GaussianMixture1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_GaussianMixture1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__Gauss1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GaussianMixture1D" "', argument " "1"" of type '" "npstat::Gauss1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GaussianMixture1D" "', argument " "1"" of type '" "npstat::Gauss1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::Gauss1D * >(argp1);
	{
	try {
	result = (npstat::GaussianMixture1D )new npstat::GaussianMixture1D((npstat::Gauss1D const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__GaussianMixture1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_GaussianMixture1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__Gauss1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_GaussianMixture1D__SWIG_2(self, args);
	}
	}
	if (argc == 3) {
	int _v;
	{
	int res = SWIG_AsVal_double(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[2], (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_GaussianMixture1D__SWIG_1(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	{
	int res = SWIG_AsVal_double(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_npstat__GaussianMixtureEntry, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_GaussianMixture1D__SWIG_0(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_GaussianMixture1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::GaussianMixture1D::GaussianMixture1D(double,double,npstat::GaussianMixtureEntry const *,unsigned int)\n"
	" npstat::GaussianMixture1D::GaussianMixture1D(double,double,std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > const &)\n"
	" npstat::GaussianMixture1D::GaussianMixture1D(npstat::Gauss1D const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_GaussianMixture1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixture1D arg1 = (npstat::GaussianMixture1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_GaussianMixture1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixture1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussianMixture1D" "', argument " "1"" of type '" "npstat::GaussianMixture1D *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixture1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixture1D_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixture1D arg1 = (npstat::GaussianMixture1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::GaussianMixture1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixture1D_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixture1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixture1D_clone" "', argument " "1"" of type '" "npstat::GaussianMixture1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixture1D * >(argp1);
	{
	try {
	result = (npstat::GaussianMixture1D )((npstat::GaussianMixture1D const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__GaussianMixture1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixture1D_nentries(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixture1D arg1 = (npstat::GaussianMixture1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixture1D_nentries",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixture1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixture1D_nentries" "', argument " "1"" of type '" "npstat::GaussianMixture1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixture1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::GaussianMixture1D const *)arg1)->nentries();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixture1D_entry(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixture1D arg1 = (npstat::GaussianMixture1D ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::GaussianMixtureEntry *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussianMixture1D_entry",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixture1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixture1D_entry" "', argument " "1"" of type '" "npstat::GaussianMixture1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixture1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussianMixture1D_entry" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (npstat::GaussianMixtureEntry ) &((npstat::GaussianMixture1D const )arg1)->entry(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__GaussianMixtureEntry, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixture1D_entries(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixture1D arg1 = (npstat::GaussianMixture1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixture1D_entries",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixture1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixture1D_entries" "', argument " "1"" of type '" "npstat::GaussianMixture1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixture1D * >(argp1);
	{
	try {
	result = (std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > ) &((npstat::GaussianMixture1D const )arg1)->entries();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< npstat::GaussianMixtureEntry,std::allocator< npstat::GaussianMixtureEntry > > >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixture1D_mean(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixture1D arg1 = (npstat::GaussianMixture1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixture1D_mean",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixture1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixture1D_mean" "', argument " "1"" of type '" "npstat::GaussianMixture1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixture1D * >(argp1);
	{
	try {
	result = (double)((npstat::GaussianMixture1D const *)arg1)->mean();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixture1D_stdev(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixture1D arg1 = (npstat::GaussianMixture1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixture1D_stdev",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixture1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixture1D_stdev" "', argument " "1"" of type '" "npstat::GaussianMixture1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixture1D * >(argp1);
	{
	try {
	result = (double)((npstat::GaussianMixture1D const *)arg1)->stdev();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixture1D_gaussianMISE(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixture1D arg1 = (npstat::GaussianMixture1D ) 0 ;
	unsigned int arg2 ;
	double arg3 ;
	unsigned long arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	unsigned long val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:GaussianMixture1D_gaussianMISE",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixture1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixture1D_gaussianMISE" "', argument " "1"" of type '" "npstat::GaussianMixture1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixture1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussianMixture1D_gaussianMISE" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GaussianMixture1D_gaussianMISE" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GaussianMixture1D_gaussianMISE" "', argument " "4"" of type '" "unsigned long""'");
	}
	arg4 = static_cast< unsigned long >(val4);
	{
	try {
	result = (double)((npstat::GaussianMixture1D const *)arg1)->gaussianMISE(arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixture1D_miseOptimalBw__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixture1D arg1 = (npstat::GaussianMixture1D ) 0 ;
	unsigned int arg2 ;
	unsigned long arg3 ;
	double arg4 = (double ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:GaussianMixture1D_miseOptimalBw",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixture1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixture1D_miseOptimalBw" "', argument " "1"" of type '" "npstat::GaussianMixture1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixture1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussianMixture1D_miseOptimalBw" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GaussianMixture1D_miseOptimalBw" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GaussianMixture1D_miseOptimalBw" "', argument " "4"" of type '" "double *""'");
	}
	arg4 = reinterpret_cast< double * >(argp4);
	{
	try {
	result = (double)((npstat::GaussianMixture1D const *)arg1)->miseOptimalBw(arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixture1D_miseOptimalBw__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixture1D arg1 = (npstat::GaussianMixture1D ) 0 ;
	unsigned int arg2 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:GaussianMixture1D_miseOptimalBw",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixture1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixture1D_miseOptimalBw" "', argument " "1"" of type '" "npstat::GaussianMixture1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixture1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussianMixture1D_miseOptimalBw" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GaussianMixture1D_miseOptimalBw" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	result = (double)((npstat::GaussianMixture1D const *)arg1)->miseOptimalBw(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixture1D_miseOptimalBw(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__GaussianMixture1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_GaussianMixture1D_miseOptimalBw__SWIG_1(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__GaussianMixture1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_GaussianMixture1D_miseOptimalBw__SWIG_0(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GaussianMixture1D_miseOptimalBw'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::GaussianMixture1D::miseOptimalBw(unsigned int,unsigned long,double *) const\n"
	" npstat::GaussianMixture1D::miseOptimalBw(unsigned int,unsigned long) const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_GaussianMixture1D_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixture1D arg1 = (npstat::GaussianMixture1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussianMixture1D_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixture1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixture1D_classId" "', argument " "1"" of type '" "npstat::GaussianMixture1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixture1D * >(argp1);
	{
	try {
	result = ((npstat::GaussianMixture1D const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixture1D_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussianMixture1D arg1 = (npstat::GaussianMixture1D ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussianMixture1D_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussianMixture1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixture1D_write" "', argument " "1"" of type '" "npstat::GaussianMixture1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussianMixture1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussianMixture1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixture1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::GaussianMixture1D const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixture1D_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":GaussianMixture1D_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::GaussianMixture1D::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixture1D_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":GaussianMixture1D_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::GaussianMixture1D::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussianMixture1D_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::GaussianMixture1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussianMixture1D_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussianMixture1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixture1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussianMixture1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussianMixture1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::GaussianMixture1D )npstat::GaussianMixture1D::read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__GaussianMixture1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject GaussianMixture1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__GaussianMixture1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DensityScanND_Linear__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistributionND *arg1 = 0 ;
	std::vector< npstat::LinearMapper1dTmpl< double >,std::allocator< npstat::LinearMapper1dTmpl< double > > > *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::DensityScanND< npstat::LinearMapper1d > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DensityScanND_Linear",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DensityScanND_Linear" "', argument " "1"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScanND_Linear" "', argument " "1"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistributionND * >(argp1);
	{
	std::vector< npstat::LinearMapper1dTmpl< double >,std::allocator< npstat::LinearMapper1dTmpl< double > > > ptr = (std::vector< npstat::LinearMapper1dTmpl< double >,std::allocator< npstat::LinearMapper1dTmpl< double > > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DensityScanND_Linear" "', argument " "2"" of type '" "std::vector< npstat::LinearMapper1dTmpl< double >,std::allocator< npstat::LinearMapper1dTmpl< double > > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScanND_Linear" "', argument " "2"" of type '" "std::vector< npstat::LinearMapper1dTmpl< double >,std::allocator< npstat::LinearMapper1dTmpl< double > > > const &""'");
	}
	arg2 = ptr;
	}
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DensityScanND_Linear" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (npstat::DensityScanND< npstat::LinearMapper1d > )new npstat::DensityScanND< npstat::LinearMapper1d >((npstat::AbsDistributionND const &)arg1,(std::vector< npstat::LinearMapper1dTmpl< double >,std::allocator< npstat::LinearMapper1dTmpl< double > > > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DensityScanNDT_npstat__LinearMapper1dTmplT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DensityScanND_Linear__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistributionND *arg1 = 0 ;
	std::vector< npstat::LinearMapper1dTmpl< double >,std::allocator< npstat::LinearMapper1dTmpl< double > > > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::DensityScanND< npstat::LinearMapper1d > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_DensityScanND_Linear",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DensityScanND_Linear" "', argument " "1"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScanND_Linear" "', argument " "1"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistributionND * >(argp1);
	{
	std::vector< npstat::LinearMapper1dTmpl< double >,std::allocator< npstat::LinearMapper1dTmpl< double > > > ptr = (std::vector< npstat::LinearMapper1dTmpl< double >,std::allocator< npstat::LinearMapper1dTmpl< double > > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DensityScanND_Linear" "', argument " "2"" of type '" "std::vector< npstat::LinearMapper1dTmpl< double >,std::allocator< npstat::LinearMapper1dTmpl< double > > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScanND_Linear" "', argument " "2"" of type '" "std::vector< npstat::LinearMapper1dTmpl< double >,std::allocator< npstat::LinearMapper1dTmpl< double > > > const &""'");
	}
	arg2 = ptr;
	}
	{
	try {
	result = (npstat::DensityScanND< npstat::LinearMapper1d > )new npstat::DensityScanND< npstat::LinearMapper1d >((npstat::AbsDistributionND const &)arg1,(std::vector< npstat::LinearMapper1dTmpl< double >,std::allocator< npstat::LinearMapper1dTmpl< double > > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DensityScanNDT_npstat__LinearMapper1dTmplT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DensityScanND_Linear(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[1], (std::vector< npstat::LinearMapper1dTmpl< double >,std::allocator< npstat::LinearMapper1dTmpl< double > > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DensityScanND_Linear__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[1], (std::vector< npstat::LinearMapper1dTmpl< double >,std::allocator< npstat::LinearMapper1dTmpl< double > > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DensityScanND_Linear__SWIG_0(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DensityScanND_Linear'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::DensityScanND< npstat::LinearMapper1d >::DensityScanND(npstat::AbsDistributionND const &,std::vector< npstat::LinearMapper1dTmpl< double >,std::allocator< npstat::LinearMapper1dTmpl< double > > > const &,double)\n"
	" npstat::DensityScanND< npstat::LinearMapper1d >::DensityScanND(npstat::AbsDistributionND const &,std::vector< npstat::LinearMapper1dTmpl< double >,std::allocator< npstat::LinearMapper1dTmpl< double > > > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DensityScanND_Linear___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScanND< npstat::LinearMapper1d > arg1 = (npstat::DensityScanND< npstat::LinearMapper1d > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DensityScanND_Linear___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScanNDT_npstat__LinearMapper1dTmplT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityScanND_Linear___call__" "', argument " "1"" of type '" "npstat::DensityScanND< npstat::LinearMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScanND< npstat::LinearMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DensityScanND_Linear___call__" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DensityScanND_Linear___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::DensityScanND< npstat::LinearMapper1d > const )arg1)->operator ()((unsigned int const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DensityScanND_Linear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScanND< npstat::LinearMapper1d > arg1 = (npstat::DensityScanND< npstat::LinearMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DensityScanND_Linear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScanNDT_npstat__LinearMapper1dTmplT_double_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DensityScanND_Linear" "', argument " "1"" of type '" "npstat::DensityScanND< npstat::LinearMapper1d > *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScanND< npstat::LinearMapper1d > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DensityScanND_Linear_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__DensityScanNDT_npstat__LinearMapper1dTmplT_double_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DensityScanND_Log__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistributionND *arg1 = 0 ;
	std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::DensityScanND< npstat::LogMapper1d > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DensityScanND_Log",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DensityScanND_Log" "', argument " "1"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScanND_Log" "', argument " "1"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistributionND * >(argp1);
	{
	std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > ptr = (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DensityScanND_Log" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScanND_Log" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > const &""'");
	}
	arg2 = ptr;
	}
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DensityScanND_Log" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (npstat::DensityScanND< npstat::LogMapper1d > )new npstat::DensityScanND< npstat::LogMapper1d >((npstat::AbsDistributionND const &)arg1,(std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DensityScanNDT_npstat__LogMapper1d_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DensityScanND_Log__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistributionND *arg1 = 0 ;
	std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::DensityScanND< npstat::LogMapper1d > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_DensityScanND_Log",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DensityScanND_Log" "', argument " "1"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScanND_Log" "', argument " "1"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistributionND * >(argp1);
	{
	std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > ptr = (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DensityScanND_Log" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScanND_Log" "', argument " "2"" of type '" "std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > const &""'");
	}
	arg2 = ptr;
	}
	{
	try {
	result = (npstat::DensityScanND< npstat::LogMapper1d > )new npstat::DensityScanND< npstat::LogMapper1d >((npstat::AbsDistributionND const &)arg1,(std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DensityScanNDT_npstat__LogMapper1d_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DensityScanND_Log(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[1], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DensityScanND_Log__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[1], (std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DensityScanND_Log__SWIG_0(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DensityScanND_Log'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::DensityScanND< npstat::LogMapper1d >::DensityScanND(npstat::AbsDistributionND const &,std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > const &,double)\n"
	" npstat::DensityScanND< npstat::LogMapper1d >::DensityScanND(npstat::AbsDistributionND const &,std::vector< npstat::LogMapper1d,std::allocator< npstat::LogMapper1d > > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DensityScanND_Log___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScanND< npstat::LogMapper1d > arg1 = (npstat::DensityScanND< npstat::LogMapper1d > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DensityScanND_Log___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScanNDT_npstat__LogMapper1d_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityScanND_Log___call__" "', argument " "1"" of type '" "npstat::DensityScanND< npstat::LogMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScanND< npstat::LogMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DensityScanND_Log___call__" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DensityScanND_Log___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::DensityScanND< npstat::LogMapper1d > const )arg1)->operator ()((unsigned int const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DensityScanND_Log(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScanND< npstat::LogMapper1d > arg1 = (npstat::DensityScanND< npstat::LogMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DensityScanND_Log",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScanNDT_npstat__LogMapper1d_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DensityScanND_Log" "', argument " "1"" of type '" "npstat::DensityScanND< npstat::LogMapper1d > *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScanND< npstat::LogMapper1d > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DensityScanND_Log_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__DensityScanNDT_npstat__LogMapper1d_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DensityScanND_Circular__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistributionND *arg1 = 0 ;
	std::vector< npstat::CircularMapper1d,std::allocator< npstat::CircularMapper1d > > *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::DensityScanND< npstat::CircularMapper1d > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DensityScanND_Circular",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DensityScanND_Circular" "', argument " "1"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScanND_Circular" "', argument " "1"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistributionND * >(argp1);
	{
	std::vector< npstat::CircularMapper1d,std::allocator< npstat::CircularMapper1d > > ptr = (std::vector< npstat::CircularMapper1d,std::allocator< npstat::CircularMapper1d > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DensityScanND_Circular" "', argument " "2"" of type '" "std::vector< npstat::CircularMapper1d,std::allocator< npstat::CircularMapper1d > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScanND_Circular" "', argument " "2"" of type '" "std::vector< npstat::CircularMapper1d,std::allocator< npstat::CircularMapper1d > > const &""'");
	}
	arg2 = ptr;
	}
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DensityScanND_Circular" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (npstat::DensityScanND< npstat::CircularMapper1d > )new npstat::DensityScanND< npstat::CircularMapper1d >((npstat::AbsDistributionND const &)arg1,(std::vector< npstat::CircularMapper1d,std::allocator< npstat::CircularMapper1d > > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DensityScanNDT_npstat__CircularMapper1d_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DensityScanND_Circular__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistributionND *arg1 = 0 ;
	std::vector< npstat::CircularMapper1d,std::allocator< npstat::CircularMapper1d > > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::DensityScanND< npstat::CircularMapper1d > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_DensityScanND_Circular",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DensityScanND_Circular" "', argument " "1"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScanND_Circular" "', argument " "1"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistributionND * >(argp1);
	{
	std::vector< npstat::CircularMapper1d,std::allocator< npstat::CircularMapper1d > > ptr = (std::vector< npstat::CircularMapper1d,std::allocator< npstat::CircularMapper1d > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DensityScanND_Circular" "', argument " "2"" of type '" "std::vector< npstat::CircularMapper1d,std::allocator< npstat::CircularMapper1d > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScanND_Circular" "', argument " "2"" of type '" "std::vector< npstat::CircularMapper1d,std::allocator< npstat::CircularMapper1d > > const &""'");
	}
	arg2 = ptr;
	}
	{
	try {
	result = (npstat::DensityScanND< npstat::CircularMapper1d > )new npstat::DensityScanND< npstat::CircularMapper1d >((npstat::AbsDistributionND const &)arg1,(std::vector< npstat::CircularMapper1d,std::allocator< npstat::CircularMapper1d > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DensityScanNDT_npstat__CircularMapper1d_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DensityScanND_Circular(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[1], (std::vector< npstat::CircularMapper1d,std::allocator< npstat::CircularMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DensityScanND_Circular__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[1], (std::vector< npstat::CircularMapper1d,std::allocator< npstat::CircularMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DensityScanND_Circular__SWIG_0(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DensityScanND_Circular'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::DensityScanND< npstat::CircularMapper1d >::DensityScanND(npstat::AbsDistributionND const &,std::vector< npstat::CircularMapper1d,std::allocator< npstat::CircularMapper1d > > const &,double)\n"
	" npstat::DensityScanND< npstat::CircularMapper1d >::DensityScanND(npstat::AbsDistributionND const &,std::vector< npstat::CircularMapper1d,std::allocator< npstat::CircularMapper1d > > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DensityScanND_Circular___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScanND< npstat::CircularMapper1d > arg1 = (npstat::DensityScanND< npstat::CircularMapper1d > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DensityScanND_Circular___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScanNDT_npstat__CircularMapper1d_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityScanND_Circular___call__" "', argument " "1"" of type '" "npstat::DensityScanND< npstat::CircularMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScanND< npstat::CircularMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DensityScanND_Circular___call__" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DensityScanND_Circular___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::DensityScanND< npstat::CircularMapper1d > const )arg1)->operator ()((unsigned int const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DensityScanND_Circular(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScanND< npstat::CircularMapper1d > arg1 = (npstat::DensityScanND< npstat::CircularMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DensityScanND_Circular",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScanNDT_npstat__CircularMapper1d_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DensityScanND_Circular" "', argument " "1"" of type '" "npstat::DensityScanND< npstat::CircularMapper1d > *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScanND< npstat::CircularMapper1d > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DensityScanND_Circular_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__DensityScanNDT_npstat__CircularMapper1d_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DensityScanND_Interpolated__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistributionND *arg1 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::DensityScanND< npstat::LinInterpolatedTable1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DensityScanND_Interpolated",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DensityScanND_Interpolated" "', argument " "1"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScanND_Interpolated" "', argument " "1"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistributionND * >(argp1);
	{
	std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > ptr = (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DensityScanND_Interpolated" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScanND_Interpolated" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > const &""'");
	}
	arg2 = ptr;
	}
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DensityScanND_Interpolated" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (npstat::DensityScanND< npstat::LinInterpolatedTable1D > )new npstat::DensityScanND< npstat::LinInterpolatedTable1D >((npstat::AbsDistributionND const &)arg1,(std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DensityScanNDT_npstat__LinInterpolatedTable1D_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DensityScanND_Interpolated__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistributionND *arg1 = 0 ;
	std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::DensityScanND< npstat::LinInterpolatedTable1D > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_DensityScanND_Interpolated",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistributionND, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DensityScanND_Interpolated" "', argument " "1"" of type '" "npstat::AbsDistributionND const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScanND_Interpolated" "', argument " "1"" of type '" "npstat::AbsDistributionND const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistributionND * >(argp1);
	{
	std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > ptr = (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DensityScanND_Interpolated" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DensityScanND_Interpolated" "', argument " "2"" of type '" "std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > const &""'");
	}
	arg2 = ptr;
	}
	{
	try {
	result = (npstat::DensityScanND< npstat::LinInterpolatedTable1D > )new npstat::DensityScanND< npstat::LinInterpolatedTable1D >((npstat::AbsDistributionND const &)arg1,(std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DensityScanNDT_npstat__LinInterpolatedTable1D_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DensityScanND_Interpolated(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[1], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DensityScanND_Interpolated__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[1], (std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DensityScanND_Interpolated__SWIG_0(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DensityScanND_Interpolated'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::DensityScanND< npstat::LinInterpolatedTable1D >::DensityScanND(npstat::AbsDistributionND const &,std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > const &,double)\n"
	" npstat::DensityScanND< npstat::LinInterpolatedTable1D >::DensityScanND(npstat::AbsDistributionND const &,std::vector< npstat::LinInterpolatedTable1D,std::allocator< npstat::LinInterpolatedTable1D > > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DensityScanND_Interpolated___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScanND< npstat::LinInterpolatedTable1D > arg1 = (npstat::DensityScanND< npstat::LinInterpolatedTable1D > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DensityScanND_Interpolated___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScanNDT_npstat__LinInterpolatedTable1D_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DensityScanND_Interpolated___call__" "', argument " "1"" of type '" "npstat::DensityScanND< npstat::LinInterpolatedTable1D > const *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScanND< npstat::LinInterpolatedTable1D > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DensityScanND_Interpolated___call__" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DensityScanND_Interpolated___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::DensityScanND< npstat::LinInterpolatedTable1D > const )arg1)->operator ()((unsigned int const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DensityScanND_Interpolated(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DensityScanND< npstat::LinInterpolatedTable1D > arg1 = (npstat::DensityScanND< npstat::LinInterpolatedTable1D > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DensityScanND_Interpolated",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DensityScanNDT_npstat__LinInterpolatedTable1D_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DensityScanND_Interpolated" "', argument " "1"" of type '" "npstat::DensityScanND< npstat::LinInterpolatedTable1D > *""'");
	}
	arg1 = reinterpret_cast< npstat::DensityScanND< npstat::LinInterpolatedTable1D > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DensityScanND_Interpolated_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__DensityScanNDT_npstat__LinInterpolatedTable1D_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_AbsPolyFilterND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsPolyFilterND arg1 = (npstat::AbsPolyFilterND ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_AbsPolyFilterND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsPolyFilterND, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AbsPolyFilterND" "', argument " "1"" of type '" "npstat::AbsPolyFilterND *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsPolyFilterND * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsPolyFilterND_dim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsPolyFilterND arg1 = (npstat::AbsPolyFilterND ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsPolyFilterND_dim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsPolyFilterND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsPolyFilterND_dim" "', argument " "1"" of type '" "npstat::AbsPolyFilterND const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsPolyFilterND * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::AbsPolyFilterND const *)arg1)->dim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsPolyFilterND_dataShape(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsPolyFilterND arg1 = (npstat::AbsPolyFilterND ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< unsigned int,std::allocator< unsigned int > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsPolyFilterND_dataShape",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsPolyFilterND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsPolyFilterND_dataShape" "', argument " "1"" of type '" "npstat::AbsPolyFilterND const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsPolyFilterND * >(argp1);
	{
	try {
	result = ((npstat::AbsPolyFilterND const *)arg1)->dataShape();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsPolyFilterND_selfContribution(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsPolyFilterND arg1 = (npstat::AbsPolyFilterND ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:AbsPolyFilterND_selfContribution",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsPolyFilterND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsPolyFilterND_selfContribution" "', argument " "1"" of type '" "npstat::AbsPolyFilterND const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsPolyFilterND * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbsPolyFilterND_selfContribution" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbsPolyFilterND_selfContribution" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::AbsPolyFilterND const )arg1)->selfContribution((unsigned int const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsPolyFilterND_linearSelfContribution(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsPolyFilterND arg1 = (npstat::AbsPolyFilterND ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:AbsPolyFilterND_linearSelfContribution",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsPolyFilterND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsPolyFilterND_linearSelfContribution" "', argument " "1"" of type '" "npstat::AbsPolyFilterND const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsPolyFilterND * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbsPolyFilterND_linearSelfContribution" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (double)((npstat::AbsPolyFilterND const *)arg1)->linearSelfContribution(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject AbsPolyFilterND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsPolyFilterND, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_DoubleDoubleAbsVisitor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< double,double > arg1 = (npstat::AbsVisitor< double,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleDoubleAbsVisitor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_double_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleDoubleAbsVisitor" "', argument " "1"" of type '" "npstat::AbsVisitor< double,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< double,double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDoubleAbsVisitor_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< double,double > arg1 = (npstat::AbsVisitor< double,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleDoubleAbsVisitor_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_double_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleAbsVisitor_clear" "', argument " "1"" of type '" "npstat::AbsVisitor< double,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< double,double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDoubleAbsVisitor_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< double,double > arg1 = (npstat::AbsVisitor< double,double > ) 0 ;
	double *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleDoubleAbsVisitor_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_double_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleAbsVisitor_process" "', argument " "1"" of type '" "npstat::AbsVisitor< double,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< double,double > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDoubleAbsVisitor_process" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((double const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDoubleAbsVisitor_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< double,double > arg1 = (npstat::AbsVisitor< double,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleDoubleAbsVisitor_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_double_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleAbsVisitor_result" "', argument " "1"" of type '" "npstat::AbsVisitor< double,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< double,double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleDoubleAbsVisitor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsVisitorT_double_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_FloatFloatAbsVisitor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< float,float > arg1 = (npstat::AbsVisitor< float,float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatFloatAbsVisitor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_float_float_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatFloatAbsVisitor" "', argument " "1"" of type '" "npstat::AbsVisitor< float,float > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< float,float > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatFloatAbsVisitor_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< float,float > arg1 = (npstat::AbsVisitor< float,float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatFloatAbsVisitor_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_float_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatFloatAbsVisitor_clear" "', argument " "1"" of type '" "npstat::AbsVisitor< float,float > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< float,float > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatFloatAbsVisitor_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< float,float > arg1 = (npstat::AbsVisitor< float,float > ) 0 ;
	float *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	float temp2 ;
	float val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatFloatAbsVisitor_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_float_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatFloatAbsVisitor_process" "', argument " "1"" of type '" "npstat::AbsVisitor< float,float > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< float,float > * >(argp1);
	ecode2 = SWIG_AsVal_float(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatFloatAbsVisitor_process" "', argument " "2"" of type '" "float""'");
	}
	temp2 = static_cast< float >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((float const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatFloatAbsVisitor_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< float,float > arg1 = (npstat::AbsVisitor< float,float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatFloatAbsVisitor_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_float_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatFloatAbsVisitor_result" "', argument " "1"" of type '" "npstat::AbsVisitor< float,float > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< float,float > * >(argp1);
	{
	try {
	result = (float)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatFloatAbsVisitor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsVisitorT_float_float_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_IntIntAbsVisitor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< int,int > arg1 = (npstat::AbsVisitor< int,int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_IntIntAbsVisitor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_int_int_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntIntAbsVisitor" "', argument " "1"" of type '" "npstat::AbsVisitor< int,int > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< int,int > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntIntAbsVisitor_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< int,int > arg1 = (npstat::AbsVisitor< int,int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:IntIntAbsVisitor_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_int_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntAbsVisitor_clear" "', argument " "1"" of type '" "npstat::AbsVisitor< int,int > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< int,int > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntIntAbsVisitor_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< int,int > arg1 = (npstat::AbsVisitor< int,int > ) 0 ;
	int *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int temp2 ;
	int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:IntIntAbsVisitor_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_int_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntAbsVisitor_process" "', argument " "1"" of type '" "npstat::AbsVisitor< int,int > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< int,int > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntIntAbsVisitor_process" "', argument " "2"" of type '" "int""'");
	}
	temp2 = static_cast< int >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((int const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntIntAbsVisitor_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< int,int > arg1 = (npstat::AbsVisitor< int,int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	int result;

	if (!PyArg_ParseTuple(args,(char *)"O:IntIntAbsVisitor_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_int_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntAbsVisitor_result" "', argument " "1"" of type '" "npstat::AbsVisitor< int,int > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< int,int > * >(argp1);
	{
	try {
	result = (int)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_int(static_cast< int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject IntIntAbsVisitor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsVisitorT_int_int_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_LLongLLongAbsVisitor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< long long,long long > arg1 = (npstat::AbsVisitor< long long,long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LLongLLongAbsVisitor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_long_long_long_long_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LLongLLongAbsVisitor" "', argument " "1"" of type '" "npstat::AbsVisitor< long long,long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< long long,long long > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongLLongAbsVisitor_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< long long,long long > arg1 = (npstat::AbsVisitor< long long,long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongLLongAbsVisitor_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_long_long_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongLLongAbsVisitor_clear" "', argument " "1"" of type '" "npstat::AbsVisitor< long long,long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< long long,long long > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongLLongAbsVisitor_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< long long,long long > arg1 = (npstat::AbsVisitor< long long,long long > ) 0 ;
	long long *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	long long temp2 ;
	long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LLongLLongAbsVisitor_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_long_long_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongLLongAbsVisitor_process" "', argument " "1"" of type '" "npstat::AbsVisitor< long long,long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< long long,long long > * >(argp1);
	ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LLongLLongAbsVisitor_process" "', argument " "2"" of type '" "long long""'");
	}
	temp2 = static_cast< long long >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((long long const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongLLongAbsVisitor_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< long long,long long > arg1 = (npstat::AbsVisitor< long long,long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	long long result;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongLLongAbsVisitor_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_long_long_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongLLongAbsVisitor_result" "', argument " "1"" of type '" "npstat::AbsVisitor< long long,long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< long long,long long > * >(argp1);
	{
	try {
	result = (long long)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject LLongLLongAbsVisitor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsVisitorT_long_long_long_long_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_UCharUCharAbsVisitor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< unsigned char,unsigned char > arg1 = (npstat::AbsVisitor< unsigned char,unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_UCharUCharAbsVisitor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_unsigned_char_unsigned_char_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UCharUCharAbsVisitor" "', argument " "1"" of type '" "npstat::AbsVisitor< unsigned char,unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< unsigned char,unsigned char > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharUCharAbsVisitor_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< unsigned char,unsigned char > arg1 = (npstat::AbsVisitor< unsigned char,unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharUCharAbsVisitor_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_unsigned_char_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharUCharAbsVisitor_clear" "', argument " "1"" of type '" "npstat::AbsVisitor< unsigned char,unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< unsigned char,unsigned char > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharUCharAbsVisitor_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< unsigned char,unsigned char > arg1 = (npstat::AbsVisitor< unsigned char,unsigned char > ) 0 ;
	unsigned char *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned char temp2 ;
	unsigned char val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:UCharUCharAbsVisitor_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_unsigned_char_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharUCharAbsVisitor_process" "', argument " "1"" of type '" "npstat::AbsVisitor< unsigned char,unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< unsigned char,unsigned char > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UCharUCharAbsVisitor_process" "', argument " "2"" of type '" "unsigned char""'");
	}
	temp2 = static_cast< unsigned char >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((unsigned char const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharUCharAbsVisitor_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< unsigned char,unsigned char > arg1 = (npstat::AbsVisitor< unsigned char,unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned char result;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharUCharAbsVisitor_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_unsigned_char_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharUCharAbsVisitor_result" "', argument " "1"" of type '" "npstat::AbsVisitor< unsigned char,unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< unsigned char,unsigned char > * >(argp1);
	{
	try {
	result = (unsigned char)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject UCharUCharAbsVisitor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsVisitorT_unsigned_char_unsigned_char_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_FloatDoubleAbsVisitor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< float,double > arg1 = (npstat::AbsVisitor< float,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatDoubleAbsVisitor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_float_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatDoubleAbsVisitor" "', argument " "1"" of type '" "npstat::AbsVisitor< float,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< float,double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDoubleAbsVisitor_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< float,double > arg1 = (npstat::AbsVisitor< float,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatDoubleAbsVisitor_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_float_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDoubleAbsVisitor_clear" "', argument " "1"" of type '" "npstat::AbsVisitor< float,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< float,double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDoubleAbsVisitor_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< float,double > arg1 = (npstat::AbsVisitor< float,double > ) 0 ;
	float *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	float temp2 ;
	float val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatDoubleAbsVisitor_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_float_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDoubleAbsVisitor_process" "', argument " "1"" of type '" "npstat::AbsVisitor< float,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< float,double > * >(argp1);
	ecode2 = SWIG_AsVal_float(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatDoubleAbsVisitor_process" "', argument " "2"" of type '" "float""'");
	}
	temp2 = static_cast< float >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((float const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDoubleAbsVisitor_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< float,double > arg1 = (npstat::AbsVisitor< float,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatDoubleAbsVisitor_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_float_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDoubleAbsVisitor_result" "', argument " "1"" of type '" "npstat::AbsVisitor< float,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< float,double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatDoubleAbsVisitor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsVisitorT_float_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_IntDoubleAbsVisitor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< int,double > arg1 = (npstat::AbsVisitor< int,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_IntDoubleAbsVisitor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_int_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntDoubleAbsVisitor" "', argument " "1"" of type '" "npstat::AbsVisitor< int,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< int,double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntDoubleAbsVisitor_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< int,double > arg1 = (npstat::AbsVisitor< int,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:IntDoubleAbsVisitor_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_int_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntDoubleAbsVisitor_clear" "', argument " "1"" of type '" "npstat::AbsVisitor< int,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< int,double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntDoubleAbsVisitor_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< int,double > arg1 = (npstat::AbsVisitor< int,double > ) 0 ;
	int *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int temp2 ;
	int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:IntDoubleAbsVisitor_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_int_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntDoubleAbsVisitor_process" "', argument " "1"" of type '" "npstat::AbsVisitor< int,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< int,double > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntDoubleAbsVisitor_process" "', argument " "2"" of type '" "int""'");
	}
	temp2 = static_cast< int >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((int const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntDoubleAbsVisitor_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< int,double > arg1 = (npstat::AbsVisitor< int,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:IntDoubleAbsVisitor_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_int_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntDoubleAbsVisitor_result" "', argument " "1"" of type '" "npstat::AbsVisitor< int,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< int,double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject IntDoubleAbsVisitor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsVisitorT_int_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_LLongDoubleAbsVisitor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< long long,double > arg1 = (npstat::AbsVisitor< long long,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LLongDoubleAbsVisitor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_long_long_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LLongDoubleAbsVisitor" "', argument " "1"" of type '" "npstat::AbsVisitor< long long,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< long long,double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongDoubleAbsVisitor_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< long long,double > arg1 = (npstat::AbsVisitor< long long,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongDoubleAbsVisitor_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_long_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongDoubleAbsVisitor_clear" "', argument " "1"" of type '" "npstat::AbsVisitor< long long,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< long long,double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongDoubleAbsVisitor_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< long long,double > arg1 = (npstat::AbsVisitor< long long,double > ) 0 ;
	long long *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	long long temp2 ;
	long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LLongDoubleAbsVisitor_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_long_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongDoubleAbsVisitor_process" "', argument " "1"" of type '" "npstat::AbsVisitor< long long,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< long long,double > * >(argp1);
	ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LLongDoubleAbsVisitor_process" "', argument " "2"" of type '" "long long""'");
	}
	temp2 = static_cast< long long >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((long long const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongDoubleAbsVisitor_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< long long,double > arg1 = (npstat::AbsVisitor< long long,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongDoubleAbsVisitor_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_long_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongDoubleAbsVisitor_result" "', argument " "1"" of type '" "npstat::AbsVisitor< long long,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< long long,double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject LLongDoubleAbsVisitor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsVisitorT_long_long_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_UCharDoubleAbsVisitor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< unsigned char,double > arg1 = (npstat::AbsVisitor< unsigned char,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_UCharDoubleAbsVisitor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_unsigned_char_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UCharDoubleAbsVisitor" "', argument " "1"" of type '" "npstat::AbsVisitor< unsigned char,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< unsigned char,double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharDoubleAbsVisitor_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< unsigned char,double > arg1 = (npstat::AbsVisitor< unsigned char,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharDoubleAbsVisitor_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_unsigned_char_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharDoubleAbsVisitor_clear" "', argument " "1"" of type '" "npstat::AbsVisitor< unsigned char,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< unsigned char,double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharDoubleAbsVisitor_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< unsigned char,double > arg1 = (npstat::AbsVisitor< unsigned char,double > ) 0 ;
	unsigned char *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned char temp2 ;
	unsigned char val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:UCharDoubleAbsVisitor_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_unsigned_char_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharDoubleAbsVisitor_process" "', argument " "1"" of type '" "npstat::AbsVisitor< unsigned char,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< unsigned char,double > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UCharDoubleAbsVisitor_process" "', argument " "2"" of type '" "unsigned char""'");
	}
	temp2 = static_cast< unsigned char >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((unsigned char const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharDoubleAbsVisitor_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsVisitor< unsigned char,double > arg1 = (npstat::AbsVisitor< unsigned char,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharDoubleAbsVisitor_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsVisitorT_unsigned_char_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharDoubleAbsVisitor_result" "', argument " "1"" of type '" "npstat::AbsVisitor< unsigned char,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsVisitor< unsigned char,double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject UCharDoubleAbsVisitor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsVisitorT_unsigned_char_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_UCharArrayMinProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< unsigned char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_UCharArrayMinProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMinProjector< unsigned char > *)new npstat::ArrayMinProjector< unsigned char >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMinProjectorT_unsigned_char_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_UCharArrayMinProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< unsigned char > arg1 = (npstat::ArrayMinProjector< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_UCharArrayMinProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_unsigned_char_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UCharArrayMinProjector" "', argument " "1"" of type '" "npstat::ArrayMinProjector< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< unsigned char > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharArrayMinProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< unsigned char > arg1 = (npstat::ArrayMinProjector< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharArrayMinProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharArrayMinProjector_clear" "', argument " "1"" of type '" "npstat::ArrayMinProjector< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< unsigned char > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharArrayMinProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< unsigned char > arg1 = (npstat::ArrayMinProjector< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned char result;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharArrayMinProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharArrayMinProjector_result" "', argument " "1"" of type '" "npstat::ArrayMinProjector< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< unsigned char > * >(argp1);
	{
	try {
	result = (unsigned char)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharArrayMinProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< unsigned char > arg1 = (npstat::ArrayMinProjector< unsigned char > ) 0 ;
	unsigned char *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned char temp2 ;
	unsigned char val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:UCharArrayMinProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharArrayMinProjector_process" "', argument " "1"" of type '" "npstat::ArrayMinProjector< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< unsigned char > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UCharArrayMinProjector_process" "', argument " "2"" of type '" "unsigned char""'");
	}
	temp2 = static_cast< unsigned char >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((unsigned char const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject UCharArrayMinProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMinProjectorT_unsigned_char_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_IntArrayMinProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< int > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_IntArrayMinProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMinProjector< int > *)new npstat::ArrayMinProjector< int >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMinProjectorT_int_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_IntArrayMinProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< int > arg1 = (npstat::ArrayMinProjector< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_IntArrayMinProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_int_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntArrayMinProjector" "', argument " "1"" of type '" "npstat::ArrayMinProjector< int > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< int > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntArrayMinProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< int > arg1 = (npstat::ArrayMinProjector< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:IntArrayMinProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArrayMinProjector_clear" "', argument " "1"" of type '" "npstat::ArrayMinProjector< int > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< int > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntArrayMinProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< int > arg1 = (npstat::ArrayMinProjector< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	int result;

	if (!PyArg_ParseTuple(args,(char *)"O:IntArrayMinProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArrayMinProjector_result" "', argument " "1"" of type '" "npstat::ArrayMinProjector< int > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< int > * >(argp1);
	{
	try {
	result = (int)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_int(static_cast< int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntArrayMinProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< int > arg1 = (npstat::ArrayMinProjector< int > ) 0 ;
	int *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int temp2 ;
	int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:IntArrayMinProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArrayMinProjector_process" "', argument " "1"" of type '" "npstat::ArrayMinProjector< int > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< int > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntArrayMinProjector_process" "', argument " "2"" of type '" "int""'");
	}
	temp2 = static_cast< int >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((int const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject IntArrayMinProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMinProjectorT_int_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_LLongArrayMinProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< long long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_LLongArrayMinProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMinProjector< long long > *)new npstat::ArrayMinProjector< long long >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMinProjectorT_long_long_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_LLongArrayMinProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< long long > arg1 = (npstat::ArrayMinProjector< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LLongArrayMinProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_long_long_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LLongArrayMinProjector" "', argument " "1"" of type '" "npstat::ArrayMinProjector< long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< long long > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongArrayMinProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< long long > arg1 = (npstat::ArrayMinProjector< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongArrayMinProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongArrayMinProjector_clear" "', argument " "1"" of type '" "npstat::ArrayMinProjector< long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< long long > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongArrayMinProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< long long > arg1 = (npstat::ArrayMinProjector< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	long long result;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongArrayMinProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongArrayMinProjector_result" "', argument " "1"" of type '" "npstat::ArrayMinProjector< long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< long long > * >(argp1);
	{
	try {
	result = (long long)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongArrayMinProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< long long > arg1 = (npstat::ArrayMinProjector< long long > ) 0 ;
	long long *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	long long temp2 ;
	long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LLongArrayMinProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongArrayMinProjector_process" "', argument " "1"" of type '" "npstat::ArrayMinProjector< long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< long long > * >(argp1);
	ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LLongArrayMinProjector_process" "', argument " "2"" of type '" "long long""'");
	}
	temp2 = static_cast< long long >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((long long const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject LLongArrayMinProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMinProjectorT_long_long_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_FloatArrayMinProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_FloatArrayMinProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMinProjector< float > *)new npstat::ArrayMinProjector< float >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMinProjectorT_float_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_FloatArrayMinProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< float > arg1 = (npstat::ArrayMinProjector< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatArrayMinProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_float_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatArrayMinProjector" "', argument " "1"" of type '" "npstat::ArrayMinProjector< float > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< float > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatArrayMinProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< float > arg1 = (npstat::ArrayMinProjector< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatArrayMinProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatArrayMinProjector_clear" "', argument " "1"" of type '" "npstat::ArrayMinProjector< float > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< float > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatArrayMinProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< float > arg1 = (npstat::ArrayMinProjector< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatArrayMinProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatArrayMinProjector_result" "', argument " "1"" of type '" "npstat::ArrayMinProjector< float > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< float > * >(argp1);
	{
	try {
	result = (float)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatArrayMinProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< float > arg1 = (npstat::ArrayMinProjector< float > ) 0 ;
	float *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	float temp2 ;
	float val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatArrayMinProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatArrayMinProjector_process" "', argument " "1"" of type '" "npstat::ArrayMinProjector< float > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< float > * >(argp1);
	ecode2 = SWIG_AsVal_float(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatArrayMinProjector_process" "', argument " "2"" of type '" "float""'");
	}
	temp2 = static_cast< float >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((float const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatArrayMinProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMinProjectorT_float_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DoubleArrayMinProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_DoubleArrayMinProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMinProjector< double > *)new npstat::ArrayMinProjector< double >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMinProjectorT_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DoubleArrayMinProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< double > arg1 = (npstat::ArrayMinProjector< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleArrayMinProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleArrayMinProjector" "', argument " "1"" of type '" "npstat::ArrayMinProjector< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleArrayMinProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< double > arg1 = (npstat::ArrayMinProjector< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleArrayMinProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleArrayMinProjector_clear" "', argument " "1"" of type '" "npstat::ArrayMinProjector< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleArrayMinProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< double > arg1 = (npstat::ArrayMinProjector< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleArrayMinProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleArrayMinProjector_result" "', argument " "1"" of type '" "npstat::ArrayMinProjector< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleArrayMinProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMinProjector< double > arg1 = (npstat::ArrayMinProjector< double > ) 0 ;
	double *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleArrayMinProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMinProjectorT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleArrayMinProjector_process" "', argument " "1"" of type '" "npstat::ArrayMinProjector< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMinProjector< double > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleArrayMinProjector_process" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((double const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleArrayMinProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMinProjectorT_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_UCharArrayMaxProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< unsigned char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_UCharArrayMaxProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMaxProjector< unsigned char > *)new npstat::ArrayMaxProjector< unsigned char >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMaxProjectorT_unsigned_char_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_UCharArrayMaxProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< unsigned char > arg1 = (npstat::ArrayMaxProjector< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_UCharArrayMaxProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_unsigned_char_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UCharArrayMaxProjector" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< unsigned char > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharArrayMaxProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< unsigned char > arg1 = (npstat::ArrayMaxProjector< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharArrayMaxProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharArrayMaxProjector_clear" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< unsigned char > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharArrayMaxProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< unsigned char > arg1 = (npstat::ArrayMaxProjector< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned char result;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharArrayMaxProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharArrayMaxProjector_result" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< unsigned char > * >(argp1);
	{
	try {
	result = (unsigned char)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharArrayMaxProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< unsigned char > arg1 = (npstat::ArrayMaxProjector< unsigned char > ) 0 ;
	unsigned char *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned char temp2 ;
	unsigned char val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:UCharArrayMaxProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharArrayMaxProjector_process" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< unsigned char > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UCharArrayMaxProjector_process" "', argument " "2"" of type '" "unsigned char""'");
	}
	temp2 = static_cast< unsigned char >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((unsigned char const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject UCharArrayMaxProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMaxProjectorT_unsigned_char_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_IntArrayMaxProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< int > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_IntArrayMaxProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMaxProjector< int > *)new npstat::ArrayMaxProjector< int >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMaxProjectorT_int_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_IntArrayMaxProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< int > arg1 = (npstat::ArrayMaxProjector< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_IntArrayMaxProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_int_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntArrayMaxProjector" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< int > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< int > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntArrayMaxProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< int > arg1 = (npstat::ArrayMaxProjector< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:IntArrayMaxProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArrayMaxProjector_clear" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< int > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< int > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntArrayMaxProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< int > arg1 = (npstat::ArrayMaxProjector< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	int result;

	if (!PyArg_ParseTuple(args,(char *)"O:IntArrayMaxProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArrayMaxProjector_result" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< int > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< int > * >(argp1);
	{
	try {
	result = (int)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_int(static_cast< int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntArrayMaxProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< int > arg1 = (npstat::ArrayMaxProjector< int > ) 0 ;
	int *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int temp2 ;
	int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:IntArrayMaxProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArrayMaxProjector_process" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< int > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< int > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntArrayMaxProjector_process" "', argument " "2"" of type '" "int""'");
	}
	temp2 = static_cast< int >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((int const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject IntArrayMaxProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMaxProjectorT_int_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_LLongArrayMaxProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< long long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_LLongArrayMaxProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMaxProjector< long long > *)new npstat::ArrayMaxProjector< long long >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMaxProjectorT_long_long_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_LLongArrayMaxProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< long long > arg1 = (npstat::ArrayMaxProjector< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LLongArrayMaxProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_long_long_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LLongArrayMaxProjector" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< long long > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongArrayMaxProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< long long > arg1 = (npstat::ArrayMaxProjector< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongArrayMaxProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongArrayMaxProjector_clear" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< long long > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongArrayMaxProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< long long > arg1 = (npstat::ArrayMaxProjector< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	long long result;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongArrayMaxProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongArrayMaxProjector_result" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< long long > * >(argp1);
	{
	try {
	result = (long long)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongArrayMaxProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< long long > arg1 = (npstat::ArrayMaxProjector< long long > ) 0 ;
	long long *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	long long temp2 ;
	long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LLongArrayMaxProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongArrayMaxProjector_process" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< long long > * >(argp1);
	ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LLongArrayMaxProjector_process" "', argument " "2"" of type '" "long long""'");
	}
	temp2 = static_cast< long long >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((long long const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject LLongArrayMaxProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMaxProjectorT_long_long_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_FloatArrayMaxProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_FloatArrayMaxProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMaxProjector< float > *)new npstat::ArrayMaxProjector< float >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMaxProjectorT_float_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_FloatArrayMaxProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< float > arg1 = (npstat::ArrayMaxProjector< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatArrayMaxProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_float_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatArrayMaxProjector" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< float > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< float > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatArrayMaxProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< float > arg1 = (npstat::ArrayMaxProjector< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatArrayMaxProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatArrayMaxProjector_clear" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< float > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< float > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatArrayMaxProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< float > arg1 = (npstat::ArrayMaxProjector< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatArrayMaxProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatArrayMaxProjector_result" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< float > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< float > * >(argp1);
	{
	try {
	result = (float)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatArrayMaxProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< float > arg1 = (npstat::ArrayMaxProjector< float > ) 0 ;
	float *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	float temp2 ;
	float val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatArrayMaxProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatArrayMaxProjector_process" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< float > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< float > * >(argp1);
	ecode2 = SWIG_AsVal_float(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatArrayMaxProjector_process" "', argument " "2"" of type '" "float""'");
	}
	temp2 = static_cast< float >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((float const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatArrayMaxProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMaxProjectorT_float_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DoubleArrayMaxProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_DoubleArrayMaxProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMaxProjector< double > *)new npstat::ArrayMaxProjector< double >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMaxProjectorT_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DoubleArrayMaxProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< double > arg1 = (npstat::ArrayMaxProjector< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleArrayMaxProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleArrayMaxProjector" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleArrayMaxProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< double > arg1 = (npstat::ArrayMaxProjector< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleArrayMaxProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleArrayMaxProjector_clear" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleArrayMaxProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< double > arg1 = (npstat::ArrayMaxProjector< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleArrayMaxProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleArrayMaxProjector_result" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleArrayMaxProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMaxProjector< double > arg1 = (npstat::ArrayMaxProjector< double > ) 0 ;
	double *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleArrayMaxProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMaxProjectorT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleArrayMaxProjector_process" "', argument " "1"" of type '" "npstat::ArrayMaxProjector< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMaxProjector< double > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleArrayMaxProjector_process" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((double const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleArrayMaxProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMaxProjectorT_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_UCharArrayMedianProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< unsigned char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_UCharArrayMedianProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMedianProjector< unsigned char > *)new npstat::ArrayMedianProjector< unsigned char >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMedianProjectorT_unsigned_char_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_UCharArrayMedianProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< unsigned char > arg1 = (npstat::ArrayMedianProjector< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_UCharArrayMedianProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_unsigned_char_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UCharArrayMedianProjector" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< unsigned char > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharArrayMedianProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< unsigned char > arg1 = (npstat::ArrayMedianProjector< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharArrayMedianProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharArrayMedianProjector_clear" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< unsigned char > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharArrayMedianProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< unsigned char > arg1 = (npstat::ArrayMedianProjector< unsigned char > ) 0 ;
	unsigned char *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned char temp2 ;
	unsigned char val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:UCharArrayMedianProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharArrayMedianProjector_process" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< unsigned char > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UCharArrayMedianProjector_process" "', argument " "2"" of type '" "unsigned char""'");
	}
	temp2 = static_cast< unsigned char >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((unsigned char const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharArrayMedianProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< unsigned char > arg1 = (npstat::ArrayMedianProjector< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned char result;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharArrayMedianProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharArrayMedianProjector_result" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< unsigned char > * >(argp1);
	{
	try {
	result = (unsigned char)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject UCharArrayMedianProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMedianProjectorT_unsigned_char_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_IntArrayMedianProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< int > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_IntArrayMedianProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMedianProjector< int > *)new npstat::ArrayMedianProjector< int >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMedianProjectorT_int_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_IntArrayMedianProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< int > arg1 = (npstat::ArrayMedianProjector< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_IntArrayMedianProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_int_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntArrayMedianProjector" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< int > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< int > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntArrayMedianProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< int > arg1 = (npstat::ArrayMedianProjector< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:IntArrayMedianProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArrayMedianProjector_clear" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< int > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< int > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntArrayMedianProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< int > arg1 = (npstat::ArrayMedianProjector< int > ) 0 ;
	int *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int temp2 ;
	int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:IntArrayMedianProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArrayMedianProjector_process" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< int > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< int > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntArrayMedianProjector_process" "', argument " "2"" of type '" "int""'");
	}
	temp2 = static_cast< int >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((int const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntArrayMedianProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< int > arg1 = (npstat::ArrayMedianProjector< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	int result;

	if (!PyArg_ParseTuple(args,(char *)"O:IntArrayMedianProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArrayMedianProjector_result" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< int > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< int > * >(argp1);
	{
	try {
	result = (int)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_int(static_cast< int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject IntArrayMedianProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMedianProjectorT_int_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_LLongArrayMedianProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< long long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_LLongArrayMedianProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMedianProjector< long long > *)new npstat::ArrayMedianProjector< long long >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMedianProjectorT_long_long_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_LLongArrayMedianProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< long long > arg1 = (npstat::ArrayMedianProjector< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LLongArrayMedianProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_long_long_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LLongArrayMedianProjector" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< long long > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongArrayMedianProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< long long > arg1 = (npstat::ArrayMedianProjector< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongArrayMedianProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongArrayMedianProjector_clear" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< long long > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongArrayMedianProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< long long > arg1 = (npstat::ArrayMedianProjector< long long > ) 0 ;
	long long *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	long long temp2 ;
	long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LLongArrayMedianProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongArrayMedianProjector_process" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< long long > * >(argp1);
	ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LLongArrayMedianProjector_process" "', argument " "2"" of type '" "long long""'");
	}
	temp2 = static_cast< long long >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((long long const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongArrayMedianProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< long long > arg1 = (npstat::ArrayMedianProjector< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	long long result;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongArrayMedianProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongArrayMedianProjector_result" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< long long > * >(argp1);
	{
	try {
	result = (long long)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject LLongArrayMedianProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMedianProjectorT_long_long_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_FloatArrayMedianProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_FloatArrayMedianProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMedianProjector< float > *)new npstat::ArrayMedianProjector< float >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMedianProjectorT_float_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_FloatArrayMedianProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< float > arg1 = (npstat::ArrayMedianProjector< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatArrayMedianProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_float_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatArrayMedianProjector" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< float > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< float > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatArrayMedianProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< float > arg1 = (npstat::ArrayMedianProjector< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatArrayMedianProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatArrayMedianProjector_clear" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< float > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< float > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatArrayMedianProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< float > arg1 = (npstat::ArrayMedianProjector< float > ) 0 ;
	float *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	float temp2 ;
	float val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatArrayMedianProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatArrayMedianProjector_process" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< float > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< float > * >(argp1);
	ecode2 = SWIG_AsVal_float(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatArrayMedianProjector_process" "', argument " "2"" of type '" "float""'");
	}
	temp2 = static_cast< float >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((float const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatArrayMedianProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< float > arg1 = (npstat::ArrayMedianProjector< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatArrayMedianProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatArrayMedianProjector_result" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< float > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< float > * >(argp1);
	{
	try {
	result = (float)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatArrayMedianProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMedianProjectorT_float_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DoubleArrayMedianProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_DoubleArrayMedianProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMedianProjector< double > *)new npstat::ArrayMedianProjector< double >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMedianProjectorT_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DoubleArrayMedianProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< double > arg1 = (npstat::ArrayMedianProjector< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleArrayMedianProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleArrayMedianProjector" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleArrayMedianProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< double > arg1 = (npstat::ArrayMedianProjector< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleArrayMedianProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleArrayMedianProjector_clear" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleArrayMedianProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< double > arg1 = (npstat::ArrayMedianProjector< double > ) 0 ;
	double *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleArrayMedianProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleArrayMedianProjector_process" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< double > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleArrayMedianProjector_process" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((double const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleArrayMedianProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMedianProjector< double > arg1 = (npstat::ArrayMedianProjector< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleArrayMedianProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMedianProjectorT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleArrayMedianProjector_result" "', argument " "1"" of type '" "npstat::ArrayMedianProjector< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMedianProjector< double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleArrayMedianProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMedianProjectorT_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_UCharArrayRangeProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayRangeProjector< unsigned char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_UCharArrayRangeProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayRangeProjector< unsigned char > *)new npstat::ArrayRangeProjector< unsigned char >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayRangeProjectorT_unsigned_char_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_UCharArrayRangeProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayRangeProjector< unsigned char > arg1 = (npstat::ArrayRangeProjector< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_UCharArrayRangeProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayRangeProjectorT_unsigned_char_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UCharArrayRangeProjector" "', argument " "1"" of type '" "npstat::ArrayRangeProjector< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayRangeProjector< unsigned char > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharArrayRangeProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayRangeProjector< unsigned char > arg1 = (npstat::ArrayRangeProjector< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned char result;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharArrayRangeProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayRangeProjectorT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharArrayRangeProjector_result" "', argument " "1"" of type '" "npstat::ArrayRangeProjector< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayRangeProjector< unsigned char > * >(argp1);
	{
	try {
	result = (unsigned char)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject UCharArrayRangeProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayRangeProjectorT_unsigned_char_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_IntArrayRangeProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayRangeProjector< int > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_IntArrayRangeProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayRangeProjector< int > *)new npstat::ArrayRangeProjector< int >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayRangeProjectorT_int_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_IntArrayRangeProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayRangeProjector< int > arg1 = (npstat::ArrayRangeProjector< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_IntArrayRangeProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayRangeProjectorT_int_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntArrayRangeProjector" "', argument " "1"" of type '" "npstat::ArrayRangeProjector< int > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayRangeProjector< int > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntArrayRangeProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayRangeProjector< int > arg1 = (npstat::ArrayRangeProjector< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	int result;

	if (!PyArg_ParseTuple(args,(char *)"O:IntArrayRangeProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayRangeProjectorT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArrayRangeProjector_result" "', argument " "1"" of type '" "npstat::ArrayRangeProjector< int > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayRangeProjector< int > * >(argp1);
	{
	try {
	result = (int)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_int(static_cast< int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject IntArrayRangeProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayRangeProjectorT_int_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_LLongArrayRangeProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayRangeProjector< long long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_LLongArrayRangeProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayRangeProjector< long long > *)new npstat::ArrayRangeProjector< long long >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayRangeProjectorT_long_long_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_LLongArrayRangeProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayRangeProjector< long long > arg1 = (npstat::ArrayRangeProjector< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LLongArrayRangeProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayRangeProjectorT_long_long_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LLongArrayRangeProjector" "', argument " "1"" of type '" "npstat::ArrayRangeProjector< long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayRangeProjector< long long > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongArrayRangeProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayRangeProjector< long long > arg1 = (npstat::ArrayRangeProjector< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	long long result;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongArrayRangeProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayRangeProjectorT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongArrayRangeProjector_result" "', argument " "1"" of type '" "npstat::ArrayRangeProjector< long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayRangeProjector< long long > * >(argp1);
	{
	try {
	result = (long long)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject LLongArrayRangeProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayRangeProjectorT_long_long_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_FloatArrayRangeProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayRangeProjector< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_FloatArrayRangeProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayRangeProjector< float > *)new npstat::ArrayRangeProjector< float >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayRangeProjectorT_float_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_FloatArrayRangeProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayRangeProjector< float > arg1 = (npstat::ArrayRangeProjector< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatArrayRangeProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayRangeProjectorT_float_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatArrayRangeProjector" "', argument " "1"" of type '" "npstat::ArrayRangeProjector< float > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayRangeProjector< float > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatArrayRangeProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayRangeProjector< float > arg1 = (npstat::ArrayRangeProjector< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatArrayRangeProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayRangeProjectorT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatArrayRangeProjector_result" "', argument " "1"" of type '" "npstat::ArrayRangeProjector< float > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayRangeProjector< float > * >(argp1);
	{
	try {
	result = (float)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatArrayRangeProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayRangeProjectorT_float_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DoubleArrayRangeProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayRangeProjector< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_DoubleArrayRangeProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayRangeProjector< double > *)new npstat::ArrayRangeProjector< double >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayRangeProjectorT_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DoubleArrayRangeProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayRangeProjector< double > arg1 = (npstat::ArrayRangeProjector< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleArrayRangeProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayRangeProjectorT_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleArrayRangeProjector" "', argument " "1"" of type '" "npstat::ArrayRangeProjector< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayRangeProjector< double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleArrayRangeProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayRangeProjector< double > arg1 = (npstat::ArrayRangeProjector< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleArrayRangeProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayRangeProjectorT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleArrayRangeProjector_result" "', argument " "1"" of type '" "npstat::ArrayRangeProjector< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayRangeProjector< double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleArrayRangeProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayRangeProjectorT_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DoubleArraySumProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< double,double,long double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_DoubleArraySumProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArraySumProjector< double,double,long double > *)new npstat::ArraySumProjector< double,double,long double >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArraySumProjectorT_double_double_long_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DoubleArraySumProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< double,double,long double > arg1 = (npstat::ArraySumProjector< double,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleArraySumProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_double_double_long_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleArraySumProjector" "', argument " "1"" of type '" "npstat::ArraySumProjector< double,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< double,double,long double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleArraySumProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< double,double,long double > arg1 = (npstat::ArraySumProjector< double,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleArraySumProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_double_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleArraySumProjector_clear" "', argument " "1"" of type '" "npstat::ArraySumProjector< double,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< double,double,long double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleArraySumProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< double,double,long double > arg1 = (npstat::ArraySumProjector< double,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleArraySumProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_double_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleArraySumProjector_result" "', argument " "1"" of type '" "npstat::ArraySumProjector< double,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< double,double,long double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleArraySumProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< double,double,long double > arg1 = (npstat::ArraySumProjector< double,double,long double > ) 0 ;
	double *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleArraySumProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_double_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleArraySumProjector_process" "', argument " "1"" of type '" "npstat::ArraySumProjector< double,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< double,double,long double > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleArraySumProjector_process" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((double const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleArraySumProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArraySumProjectorT_double_double_long_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_FloatArraySumProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< float,double,long double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_FloatArraySumProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArraySumProjector< float,double,long double > *)new npstat::ArraySumProjector< float,double,long double >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArraySumProjectorT_float_double_long_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_FloatArraySumProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< float,double,long double > arg1 = (npstat::ArraySumProjector< float,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatArraySumProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_float_double_long_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatArraySumProjector" "', argument " "1"" of type '" "npstat::ArraySumProjector< float,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< float,double,long double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatArraySumProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< float,double,long double > arg1 = (npstat::ArraySumProjector< float,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatArraySumProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_float_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatArraySumProjector_clear" "', argument " "1"" of type '" "npstat::ArraySumProjector< float,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< float,double,long double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatArraySumProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< float,double,long double > arg1 = (npstat::ArraySumProjector< float,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatArraySumProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_float_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatArraySumProjector_result" "', argument " "1"" of type '" "npstat::ArraySumProjector< float,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< float,double,long double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatArraySumProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< float,double,long double > arg1 = (npstat::ArraySumProjector< float,double,long double > ) 0 ;
	float *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	float temp2 ;
	float val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatArraySumProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_float_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatArraySumProjector_process" "', argument " "1"" of type '" "npstat::ArraySumProjector< float,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< float,double,long double > * >(argp1);
	ecode2 = SWIG_AsVal_float(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatArraySumProjector_process" "', argument " "2"" of type '" "float""'");
	}
	temp2 = static_cast< float >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((float const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatArraySumProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArraySumProjectorT_float_double_long_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_IntArraySumProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< int,double,long double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_IntArraySumProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArraySumProjector< int,double,long double > *)new npstat::ArraySumProjector< int,double,long double >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArraySumProjectorT_int_double_long_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_IntArraySumProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< int,double,long double > arg1 = (npstat::ArraySumProjector< int,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_IntArraySumProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_int_double_long_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntArraySumProjector" "', argument " "1"" of type '" "npstat::ArraySumProjector< int,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< int,double,long double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntArraySumProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< int,double,long double > arg1 = (npstat::ArraySumProjector< int,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:IntArraySumProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_int_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArraySumProjector_clear" "', argument " "1"" of type '" "npstat::ArraySumProjector< int,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< int,double,long double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntArraySumProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< int,double,long double > arg1 = (npstat::ArraySumProjector< int,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:IntArraySumProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_int_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArraySumProjector_result" "', argument " "1"" of type '" "npstat::ArraySumProjector< int,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< int,double,long double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntArraySumProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< int,double,long double > arg1 = (npstat::ArraySumProjector< int,double,long double > ) 0 ;
	int *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int temp2 ;
	int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:IntArraySumProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_int_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArraySumProjector_process" "', argument " "1"" of type '" "npstat::ArraySumProjector< int,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< int,double,long double > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntArraySumProjector_process" "', argument " "2"" of type '" "int""'");
	}
	temp2 = static_cast< int >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((int const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject IntArraySumProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArraySumProjectorT_int_double_long_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_LLongArraySumProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< long long,double,long double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_LLongArraySumProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArraySumProjector< long long,double,long double > *)new npstat::ArraySumProjector< long long,double,long double >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArraySumProjectorT_long_long_double_long_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_LLongArraySumProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< long long,double,long double > arg1 = (npstat::ArraySumProjector< long long,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LLongArraySumProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_long_long_double_long_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LLongArraySumProjector" "', argument " "1"" of type '" "npstat::ArraySumProjector< long long,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< long long,double,long double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongArraySumProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< long long,double,long double > arg1 = (npstat::ArraySumProjector< long long,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongArraySumProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_long_long_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongArraySumProjector_clear" "', argument " "1"" of type '" "npstat::ArraySumProjector< long long,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< long long,double,long double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongArraySumProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< long long,double,long double > arg1 = (npstat::ArraySumProjector< long long,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongArraySumProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_long_long_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongArraySumProjector_result" "', argument " "1"" of type '" "npstat::ArraySumProjector< long long,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< long long,double,long double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongArraySumProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< long long,double,long double > arg1 = (npstat::ArraySumProjector< long long,double,long double > ) 0 ;
	long long *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	long long temp2 ;
	long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LLongArraySumProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_long_long_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongArraySumProjector_process" "', argument " "1"" of type '" "npstat::ArraySumProjector< long long,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< long long,double,long double > * >(argp1);
	ecode2 = SWIG_AsVal_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LLongArraySumProjector_process" "', argument " "2"" of type '" "long long""'");
	}
	temp2 = static_cast< long long >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((long long const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject LLongArraySumProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArraySumProjectorT_long_long_double_long_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_UCharArraySumProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< unsigned char,double,long double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_UCharArraySumProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArraySumProjector< unsigned char,double,long double > *)new npstat::ArraySumProjector< unsigned char,double,long double >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArraySumProjectorT_unsigned_char_double_long_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_UCharArraySumProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< unsigned char,double,long double > arg1 = (npstat::ArraySumProjector< unsigned char,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_UCharArraySumProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_unsigned_char_double_long_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UCharArraySumProjector" "', argument " "1"" of type '" "npstat::ArraySumProjector< unsigned char,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< unsigned char,double,long double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharArraySumProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< unsigned char,double,long double > arg1 = (npstat::ArraySumProjector< unsigned char,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharArraySumProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_unsigned_char_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharArraySumProjector_clear" "', argument " "1"" of type '" "npstat::ArraySumProjector< unsigned char,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< unsigned char,double,long double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharArraySumProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< unsigned char,double,long double > arg1 = (npstat::ArraySumProjector< unsigned char,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharArraySumProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_unsigned_char_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharArraySumProjector_result" "', argument " "1"" of type '" "npstat::ArraySumProjector< unsigned char,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< unsigned char,double,long double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharArraySumProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArraySumProjector< unsigned char,double,long double > arg1 = (npstat::ArraySumProjector< unsigned char,double,long double > ) 0 ;
	unsigned char *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned char temp2 ;
	unsigned char val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:UCharArraySumProjector_process",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArraySumProjectorT_unsigned_char_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharArraySumProjector_process" "', argument " "1"" of type '" "npstat::ArraySumProjector< unsigned char,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArraySumProjector< unsigned char,double,long double > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UCharArraySumProjector_process" "', argument " "2"" of type '" "unsigned char""'");
	}
	temp2 = static_cast< unsigned char >(val2);
	arg2 = &temp2;
	{
	try {
	(arg1)->process((unsigned char const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject UCharArraySumProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArraySumProjectorT_unsigned_char_double_long_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DoubleArrayMeanProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMeanProjector< double,double,long double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_DoubleArrayMeanProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMeanProjector< double,double,long double > *)new npstat::ArrayMeanProjector< double,double,long double >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMeanProjectorT_double_double_long_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DoubleArrayMeanProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMeanProjector< double,double,long double > arg1 = (npstat::ArrayMeanProjector< double,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleArrayMeanProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMeanProjectorT_double_double_long_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleArrayMeanProjector" "', argument " "1"" of type '" "npstat::ArrayMeanProjector< double,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMeanProjector< double,double,long double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleArrayMeanProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMeanProjector< double,double,long double > arg1 = (npstat::ArrayMeanProjector< double,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleArrayMeanProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMeanProjectorT_double_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleArrayMeanProjector_result" "', argument " "1"" of type '" "npstat::ArrayMeanProjector< double,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMeanProjector< double,double,long double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleArrayMeanProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMeanProjectorT_double_double_long_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_FloatArrayMeanProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMeanProjector< float,double,long double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_FloatArrayMeanProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMeanProjector< float,double,long double > *)new npstat::ArrayMeanProjector< float,double,long double >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMeanProjectorT_float_double_long_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_FloatArrayMeanProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMeanProjector< float,double,long double > arg1 = (npstat::ArrayMeanProjector< float,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatArrayMeanProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMeanProjectorT_float_double_long_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatArrayMeanProjector" "', argument " "1"" of type '" "npstat::ArrayMeanProjector< float,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMeanProjector< float,double,long double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatArrayMeanProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMeanProjector< float,double,long double > arg1 = (npstat::ArrayMeanProjector< float,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatArrayMeanProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMeanProjectorT_float_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatArrayMeanProjector_result" "', argument " "1"" of type '" "npstat::ArrayMeanProjector< float,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMeanProjector< float,double,long double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatArrayMeanProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMeanProjectorT_float_double_long_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_IntArrayMeanProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMeanProjector< int,double,long double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_IntArrayMeanProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMeanProjector< int,double,long double > *)new npstat::ArrayMeanProjector< int,double,long double >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMeanProjectorT_int_double_long_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_IntArrayMeanProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMeanProjector< int,double,long double > arg1 = (npstat::ArrayMeanProjector< int,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_IntArrayMeanProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMeanProjectorT_int_double_long_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntArrayMeanProjector" "', argument " "1"" of type '" "npstat::ArrayMeanProjector< int,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMeanProjector< int,double,long double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntArrayMeanProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMeanProjector< int,double,long double > arg1 = (npstat::ArrayMeanProjector< int,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:IntArrayMeanProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMeanProjectorT_int_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntArrayMeanProjector_result" "', argument " "1"" of type '" "npstat::ArrayMeanProjector< int,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMeanProjector< int,double,long double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject IntArrayMeanProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMeanProjectorT_int_double_long_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_LLongArrayMeanProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMeanProjector< long long,double,long double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_LLongArrayMeanProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMeanProjector< long long,double,long double > *)new npstat::ArrayMeanProjector< long long,double,long double >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMeanProjectorT_long_long_double_long_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_LLongArrayMeanProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMeanProjector< long long,double,long double > arg1 = (npstat::ArrayMeanProjector< long long,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LLongArrayMeanProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMeanProjectorT_long_long_double_long_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LLongArrayMeanProjector" "', argument " "1"" of type '" "npstat::ArrayMeanProjector< long long,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMeanProjector< long long,double,long double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongArrayMeanProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMeanProjector< long long,double,long double > arg1 = (npstat::ArrayMeanProjector< long long,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongArrayMeanProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMeanProjectorT_long_long_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongArrayMeanProjector_result" "', argument " "1"" of type '" "npstat::ArrayMeanProjector< long long,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMeanProjector< long long,double,long double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject LLongArrayMeanProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMeanProjectorT_long_long_double_long_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_UCharArrayMeanProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMeanProjector< unsigned char,double,long double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_UCharArrayMeanProjector")) SWIG_fail;
	{
	try {
	result = (npstat::ArrayMeanProjector< unsigned char,double,long double > *)new npstat::ArrayMeanProjector< unsigned char,double,long double >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayMeanProjectorT_unsigned_char_double_long_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_UCharArrayMeanProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMeanProjector< unsigned char,double,long double > arg1 = (npstat::ArrayMeanProjector< unsigned char,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_UCharArrayMeanProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMeanProjectorT_unsigned_char_double_long_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UCharArrayMeanProjector" "', argument " "1"" of type '" "npstat::ArrayMeanProjector< unsigned char,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMeanProjector< unsigned char,double,long double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharArrayMeanProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayMeanProjector< unsigned char,double,long double > arg1 = (npstat::ArrayMeanProjector< unsigned char,double,long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharArrayMeanProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ArrayMeanProjectorT_unsigned_char_double_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharArrayMeanProjector_result" "', argument " "1"" of type '" "npstat::ArrayMeanProjector< unsigned char,double,long double > *""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayMeanProjector< unsigned char,double,long double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject UCharArrayMeanProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ArrayMeanProjectorT_unsigned_char_double_long_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_KDE1DHOSymbetaKernel__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int arg1 ;
	double arg2 ;
	int val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::KDE1DHOSymbetaKernel *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_KDE1DHOSymbetaKernel",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KDE1DHOSymbetaKernel" "', argument " "1"" of type '" "int""'");
	}
	arg1 = static_cast< int >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_KDE1DHOSymbetaKernel" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (npstat::KDE1DHOSymbetaKernel *)new npstat::KDE1DHOSymbetaKernel(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__KDE1DHOSymbetaKernel, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_KDE1DHOSymbetaKernel__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1DHOSymbetaKernel *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::KDE1DHOSymbetaKernel *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_KDE1DHOSymbetaKernel",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__KDE1DHOSymbetaKernel, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_KDE1DHOSymbetaKernel" "', argument " "1"" of type '" "npstat::KDE1DHOSymbetaKernel const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_KDE1DHOSymbetaKernel" "', argument " "1"" of type '" "npstat::KDE1DHOSymbetaKernel const &""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1DHOSymbetaKernel * >(argp1);
	{
	try {
	result = (npstat::KDE1DHOSymbetaKernel )new npstat::KDE1DHOSymbetaKernel((npstat::KDE1DHOSymbetaKernel const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__KDE1DHOSymbetaKernel, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_KDE1DHOSymbetaKernel(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__KDE1DHOSymbetaKernel, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_KDE1DHOSymbetaKernel__SWIG_1(self, args);
	}
	}
	if (argc == 2) {
	int _v;
	{
	int res = SWIG_AsVal_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_KDE1DHOSymbetaKernel__SWIG_0(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_KDE1DHOSymbetaKernel'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::KDE1DHOSymbetaKernel::KDE1DHOSymbetaKernel(int,double)\n"
	" npstat::KDE1DHOSymbetaKernel::KDE1DHOSymbetaKernel(npstat::KDE1DHOSymbetaKernel const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_KDE1DHOSymbetaKernel_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1DHOSymbetaKernel arg1 = (npstat::KDE1DHOSymbetaKernel ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::KDE1DHOSymbetaKernel *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:KDE1DHOSymbetaKernel_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DHOSymbetaKernel, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDE1DHOSymbetaKernel_clone" "', argument " "1"" of type '" "npstat::KDE1DHOSymbetaKernel const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1DHOSymbetaKernel * >(argp1);
	{
	try {
	result = (npstat::KDE1DHOSymbetaKernel )((npstat::KDE1DHOSymbetaKernel const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__KDE1DHOSymbetaKernel, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_KDE1DHOSymbetaKernel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1DHOSymbetaKernel arg1 = (npstat::KDE1DHOSymbetaKernel ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_KDE1DHOSymbetaKernel",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DHOSymbetaKernel, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KDE1DHOSymbetaKernel" "', argument " "1"" of type '" "npstat::KDE1DHOSymbetaKernel *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1DHOSymbetaKernel * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_KDE1DHOSymbetaKernel_power(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1DHOSymbetaKernel arg1 = (npstat::KDE1DHOSymbetaKernel ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	int result;

	if (!PyArg_ParseTuple(args,(char *)"O:KDE1DHOSymbetaKernel_power",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DHOSymbetaKernel, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDE1DHOSymbetaKernel_power" "', argument " "1"" of type '" "npstat::KDE1DHOSymbetaKernel const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1DHOSymbetaKernel * >(argp1);
	{
	try {
	result = (int)((npstat::KDE1DHOSymbetaKernel const *)arg1)->power();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_int(static_cast< int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_KDE1DHOSymbetaKernel_filterDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1DHOSymbetaKernel arg1 = (npstat::KDE1DHOSymbetaKernel ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:KDE1DHOSymbetaKernel_filterDegree",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DHOSymbetaKernel, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDE1DHOSymbetaKernel_filterDegree" "', argument " "1"" of type '" "npstat::KDE1DHOSymbetaKernel const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1DHOSymbetaKernel * >(argp1);
	{
	try {
	result = (double)((npstat::KDE1DHOSymbetaKernel const *)arg1)->filterDegree();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_KDE1DHOSymbetaKernel_weight(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1DHOSymbetaKernel arg1 = (npstat::KDE1DHOSymbetaKernel ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:KDE1DHOSymbetaKernel_weight",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DHOSymbetaKernel, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDE1DHOSymbetaKernel_weight" "', argument " "1"" of type '" "npstat::KDE1DHOSymbetaKernel const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1DHOSymbetaKernel * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KDE1DHOSymbetaKernel_weight" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::KDE1DHOSymbetaKernel const *)arg1)->weight(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_KDE1DHOSymbetaKernel_xmin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1DHOSymbetaKernel arg1 = (npstat::KDE1DHOSymbetaKernel ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:KDE1DHOSymbetaKernel_xmin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DHOSymbetaKernel, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDE1DHOSymbetaKernel_xmin" "', argument " "1"" of type '" "npstat::KDE1DHOSymbetaKernel const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1DHOSymbetaKernel * >(argp1);
	{
	try {
	result = (double)((npstat::KDE1DHOSymbetaKernel const *)arg1)->xmin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_KDE1DHOSymbetaKernel_xmax(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1DHOSymbetaKernel arg1 = (npstat::KDE1DHOSymbetaKernel ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:KDE1DHOSymbetaKernel_xmax",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DHOSymbetaKernel, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDE1DHOSymbetaKernel_xmax" "', argument " "1"" of type '" "npstat::KDE1DHOSymbetaKernel const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1DHOSymbetaKernel * >(argp1);
	{
	try {
	result = (double)((npstat::KDE1DHOSymbetaKernel const *)arg1)->xmax();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_KDE1DHOSymbetaKernel___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1DHOSymbetaKernel arg1 = (npstat::KDE1DHOSymbetaKernel ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:KDE1DHOSymbetaKernel___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DHOSymbetaKernel, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KDE1DHOSymbetaKernel___call__" "', argument " "1"" of type '" "npstat::KDE1DHOSymbetaKernel const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1DHOSymbetaKernel * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KDE1DHOSymbetaKernel___call__" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::KDE1DHOSymbetaKernel const *)arg1)->operator ()(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject KDE1DHOSymbetaKernel_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__KDE1DHOSymbetaKernel, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_RatioOfNormals(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	npstat::RatioOfNormals *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_RatioOfNormals",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RatioOfNormals" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RatioOfNormals" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RatioOfNormals" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_RatioOfNormals" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RatioOfNormals" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	{
	try {
	result = (npstat::RatioOfNormals *)new npstat::RatioOfNormals(arg1,arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__RatioOfNormals, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_RatioOfNormals(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RatioOfNormals arg1 = (npstat::RatioOfNormals ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_RatioOfNormals",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RatioOfNormals, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RatioOfNormals" "', argument " "1"" of type '" "npstat::RatioOfNormals *""'");
	}
	arg1 = reinterpret_cast< npstat::RatioOfNormals * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RatioOfNormals_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RatioOfNormals arg1 = (npstat::RatioOfNormals ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::RatioOfNormals *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:RatioOfNormals_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RatioOfNormals, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RatioOfNormals_clone" "', argument " "1"" of type '" "npstat::RatioOfNormals const *""'");
	}
	arg1 = reinterpret_cast< npstat::RatioOfNormals * >(argp1);
	{
	try {
	result = (npstat::RatioOfNormals )((npstat::RatioOfNormals const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__RatioOfNormals, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RatioOfNormals_density(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RatioOfNormals arg1 = (npstat::RatioOfNormals ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:RatioOfNormals_density",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RatioOfNormals, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RatioOfNormals_density" "', argument " "1"" of type '" "npstat::RatioOfNormals const *""'");
	}
	arg1 = reinterpret_cast< npstat::RatioOfNormals * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RatioOfNormals_density" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::RatioOfNormals const *)arg1)->density(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RatioOfNormals_cdf(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RatioOfNormals arg1 = (npstat::RatioOfNormals ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:RatioOfNormals_cdf",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RatioOfNormals, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RatioOfNormals_cdf" "', argument " "1"" of type '" "npstat::RatioOfNormals const *""'");
	}
	arg1 = reinterpret_cast< npstat::RatioOfNormals * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RatioOfNormals_cdf" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::RatioOfNormals const *)arg1)->cdf(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RatioOfNormals_exceedance(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RatioOfNormals arg1 = (npstat::RatioOfNormals ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:RatioOfNormals_exceedance",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RatioOfNormals, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RatioOfNormals_exceedance" "', argument " "1"" of type '" "npstat::RatioOfNormals const *""'");
	}
	arg1 = reinterpret_cast< npstat::RatioOfNormals * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RatioOfNormals_exceedance" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::RatioOfNormals const *)arg1)->exceedance(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RatioOfNormals_quantile(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RatioOfNormals arg1 = (npstat::RatioOfNormals ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:RatioOfNormals_quantile",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RatioOfNormals, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RatioOfNormals_quantile" "', argument " "1"" of type '" "npstat::RatioOfNormals const *""'");
	}
	arg1 = reinterpret_cast< npstat::RatioOfNormals * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RatioOfNormals_quantile" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::RatioOfNormals const *)arg1)->quantile(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RatioOfNormals_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RatioOfNormals arg1 = (npstat::RatioOfNormals ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:RatioOfNormals_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RatioOfNormals, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RatioOfNormals_classId" "', argument " "1"" of type '" "npstat::RatioOfNormals const *""'");
	}
	arg1 = reinterpret_cast< npstat::RatioOfNormals * >(argp1);
	{
	try {
	result = ((npstat::RatioOfNormals const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RatioOfNormals_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::RatioOfNormals arg1 = (npstat::RatioOfNormals ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:RatioOfNormals_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__RatioOfNormals, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RatioOfNormals_write" "', argument " "1"" of type '" "npstat::RatioOfNormals const *""'");
	}
	arg1 = reinterpret_cast< npstat::RatioOfNormals * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RatioOfNormals_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RatioOfNormals_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::RatioOfNormals const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RatioOfNormals_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":RatioOfNormals_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::RatioOfNormals::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RatioOfNormals_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":RatioOfNormals_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::RatioOfNormals::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_RatioOfNormals_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::RatioOfNormals *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:RatioOfNormals_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RatioOfNormals_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RatioOfNormals_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RatioOfNormals_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RatioOfNormals_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::RatioOfNormals )npstat::RatioOfNormals::read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__RatioOfNormals, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject RatioOfNormals_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__RatioOfNormals, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_AbsMarginalSmootherBase(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsMarginalSmootherBase arg1 = (npstat::AbsMarginalSmootherBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_AbsMarginalSmootherBase",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsMarginalSmootherBase, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AbsMarginalSmootherBase" "', argument " "1"" of type '" "npstat::AbsMarginalSmootherBase *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsMarginalSmootherBase * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsMarginalSmootherBase_setAxisLabel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsMarginalSmootherBase arg1 = (npstat::AbsMarginalSmootherBase ) 0 ;
	char arg2 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:AbsMarginalSmootherBase_setAxisLabel",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsMarginalSmootherBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsMarginalSmootherBase_setAxisLabel" "', argument " "1"" of type '" "npstat::AbsMarginalSmootherBase *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsMarginalSmootherBase * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbsMarginalSmootherBase_setAxisLabel" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	{
	try {
	(arg1)->setAxisLabel((char const *)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsMarginalSmootherBase_nBins(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsMarginalSmootherBase arg1 = (npstat::AbsMarginalSmootherBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsMarginalSmootherBase_nBins",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsMarginalSmootherBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsMarginalSmootherBase_nBins" "', argument " "1"" of type '" "npstat::AbsMarginalSmootherBase const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsMarginalSmootherBase * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::AbsMarginalSmootherBase const *)arg1)->nBins();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsMarginalSmootherBase_xMin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsMarginalSmootherBase arg1 = (npstat::AbsMarginalSmootherBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsMarginalSmootherBase_xMin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsMarginalSmootherBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsMarginalSmootherBase_xMin" "', argument " "1"" of type '" "npstat::AbsMarginalSmootherBase const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsMarginalSmootherBase * >(argp1);
	{
	try {
	result = (double)((npstat::AbsMarginalSmootherBase const *)arg1)->xMin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsMarginalSmootherBase_xMax(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsMarginalSmootherBase arg1 = (npstat::AbsMarginalSmootherBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsMarginalSmootherBase_xMax",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsMarginalSmootherBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsMarginalSmootherBase_xMax" "', argument " "1"" of type '" "npstat::AbsMarginalSmootherBase const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsMarginalSmootherBase * >(argp1);
	{
	try {
	result = (double)((npstat::AbsMarginalSmootherBase const *)arg1)->xMax();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsMarginalSmootherBase_binWidth(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsMarginalSmootherBase arg1 = (npstat::AbsMarginalSmootherBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsMarginalSmootherBase_binWidth",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsMarginalSmootherBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsMarginalSmootherBase_binWidth" "', argument " "1"" of type '" "npstat::AbsMarginalSmootherBase const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsMarginalSmootherBase * >(argp1);
	{
	try {
	result = (double)((npstat::AbsMarginalSmootherBase const *)arg1)->binWidth();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsMarginalSmootherBase_getAxisLabel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsMarginalSmootherBase arg1 = (npstat::AbsMarginalSmootherBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::string *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsMarginalSmootherBase_getAxisLabel",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsMarginalSmootherBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsMarginalSmootherBase_getAxisLabel" "', argument " "1"" of type '" "npstat::AbsMarginalSmootherBase const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsMarginalSmootherBase * >(argp1);
	{
	try {
	result = (std::string ) &((npstat::AbsMarginalSmootherBase const )arg1)->getAxisLabel();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsMarginalSmootherBase_lastBandwidth(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsMarginalSmootherBase arg1 = (npstat::AbsMarginalSmootherBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsMarginalSmootherBase_lastBandwidth",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsMarginalSmootherBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsMarginalSmootherBase_lastBandwidth" "', argument " "1"" of type '" "npstat::AbsMarginalSmootherBase const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsMarginalSmootherBase * >(argp1);
	{
	try {
	result = (double)((npstat::AbsMarginalSmootherBase const *)arg1)->lastBandwidth();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsMarginalSmootherBase_setArchive__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsMarginalSmootherBase arg1 = (npstat::AbsMarginalSmootherBase ) 0 ;
	gs::AbsArchive arg2 = (gs::AbsArchive ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:AbsMarginalSmootherBase_setArchive",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsMarginalSmootherBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsMarginalSmootherBase_setArchive" "', argument " "1"" of type '" "npstat::AbsMarginalSmootherBase *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsMarginalSmootherBase * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gs__AbsArchive, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbsMarginalSmootherBase_setArchive" "', argument " "2"" of type '" "gs::AbsArchive *""'");
	}
	arg2 = reinterpret_cast< gs::AbsArchive * >(argp2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbsMarginalSmootherBase_setArchive" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	(arg1)->setArchive(arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsMarginalSmootherBase_setArchive__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsMarginalSmootherBase arg1 = (npstat::AbsMarginalSmootherBase ) 0 ;
	gs::AbsArchive arg2 = (gs::AbsArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:AbsMarginalSmootherBase_setArchive",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsMarginalSmootherBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsMarginalSmootherBase_setArchive" "', argument " "1"" of type '" "npstat::AbsMarginalSmootherBase *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsMarginalSmootherBase * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gs__AbsArchive, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbsMarginalSmootherBase_setArchive" "', argument " "2"" of type '" "gs::AbsArchive *""'");
	}
	arg2 = reinterpret_cast< gs::AbsArchive * >(argp2);
	{
	try {
	(arg1)->setArchive(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsMarginalSmootherBase_setArchive(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsMarginalSmootherBase, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_AbsMarginalSmootherBase_setArchive__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__AbsMarginalSmootherBase, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_AbsMarginalSmootherBase_setArchive__SWIG_0(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'AbsMarginalSmootherBase_setArchive'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::AbsMarginalSmootherBase::setArchive(gs::AbsArchive ,char const )\n"
	" npstat::AbsMarginalSmootherBase::setArchive(gs::AbsArchive *)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_AbsMarginalSmootherBase_unsetArchive(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsMarginalSmootherBase arg1 = (npstat::AbsMarginalSmootherBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsMarginalSmootherBase_unsetArchive",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsMarginalSmootherBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsMarginalSmootherBase_unsetArchive" "', argument " "1"" of type '" "npstat::AbsMarginalSmootherBase *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsMarginalSmootherBase * >(argp1);
	{
	try {
	(arg1)->unsetArchive();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsMarginalSmootherBase_smooth(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsMarginalSmootherBase arg1 = (npstat::AbsMarginalSmootherBase ) 0 ;
	std::vector< double,std::allocator< double > > *arg2 = 0 ;
	double arg3 = (double ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	double temp3 ;
	int res3 = SWIG_TMPOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	- SwigValueWrapper< npstat::HistoND< double > > result;
	+ npstat::HistoND< double,npstat::HistoAxis > *result = 0 ;

	arg3 = &temp3;
	if (!PyArg_ParseTuple(args,(char *)"OO:AbsMarginalSmootherBase_smooth",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsMarginalSmootherBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsMarginalSmootherBase_smooth" "', argument " "1"" of type '" "npstat::AbsMarginalSmootherBase *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsMarginalSmootherBase * >(argp1);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbsMarginalSmootherBase_smooth" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbsMarginalSmootherBase_smooth" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg2 = ptr;
	}
	{
	try {
	- result = (arg1)->SWIGTEMPLATEDISAMBIGUATOR smooth2< std::vector< double > >((std::vector< double,std::allocator< double > > const &)*arg2,arg3);
	+ result = (npstat::HistoND< double,npstat::HistoAxis > )(arg1)->SWIGTEMPLATEDISAMBIGUATOR smooth2< std::vector< double > >((std::vector< double,std::allocator< double > > const &)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	- resultobj = SWIG_NewPointerObj((new npstat::HistoND< double >(static_cast< const npstat::HistoND< double >& >(result))), SWIGTYPE_p_npstat__HistoNDT_double_t, SWIG_POINTER_OWN \| 0 );
	+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsTmpObj(res3)) {
	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
	} else {
	int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN \| 0 ) : 0 ;
	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
	}
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsMarginalSmootherBase_weightedSmooth(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsMarginalSmootherBase arg1 = (npstat::AbsMarginalSmootherBase ) 0 ;
	std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *arg2 = 0 ;
	double arg3 = (double ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	double temp3 ;
	int res3 = SWIG_TMPOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	- SwigValueWrapper< npstat::HistoND< double > > result;
	+ npstat::HistoND< double,npstat::HistoAxis > *result = 0 ;

	arg3 = &temp3;
	if (!PyArg_ParseTuple(args,(char *)"OO:AbsMarginalSmootherBase_weightedSmooth",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsMarginalSmootherBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsMarginalSmootherBase_weightedSmooth" "', argument " "1"" of type '" "npstat::AbsMarginalSmootherBase *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsMarginalSmootherBase * >(argp1);
	{
	std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > ptr = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbsMarginalSmootherBase_weightedSmooth" "', argument " "2"" of type '" "std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbsMarginalSmootherBase_weightedSmooth" "', argument " "2"" of type '" "std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &""'");
	}
	arg2 = ptr;
	}
	{
	try {
	- result = (arg1)->SWIGTEMPLATEDISAMBIGUATOR weightedSmooth2< std::vector< std::pair< double,double > > >((std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)*arg2,arg3);
	+ result = (npstat::HistoND< double,npstat::HistoAxis > )(arg1)->SWIGTEMPLATEDISAMBIGUATOR weightedSmooth2< std::vector< std::pair< double,double > > >((std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	- resultobj = SWIG_NewPointerObj((new npstat::HistoND< double >(static_cast< const npstat::HistoND< double >& >(result))), SWIGTYPE_p_npstat__HistoNDT_double_t, SWIG_POINTER_OWN \| 0 );
	+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsTmpObj(res3)) {
	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
	} else {
	int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN \| 0 ) : 0 ;
	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
	}
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsMarginalSmootherBase_smoothArch(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsMarginalSmootherBase arg1 = (npstat::AbsMarginalSmootherBase ) 0 ;
	std::vector< double,std::allocator< double > > *arg2 = 0 ;
	unsigned long arg3 ;
	unsigned int arg4 ;
	double arg5 = (double ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	double temp5 ;
	int res5 = SWIG_TMPOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	- SwigValueWrapper< npstat::HistoND< double > > result;
	+ npstat::HistoND< double,npstat::HistoAxis > *result = 0 ;

	arg5 = &temp5;
	if (!PyArg_ParseTuple(args,(char *)"OOOO:AbsMarginalSmootherBase_smoothArch",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsMarginalSmootherBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsMarginalSmootherBase_smoothArch" "', argument " "1"" of type '" "npstat::AbsMarginalSmootherBase *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsMarginalSmootherBase * >(argp1);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbsMarginalSmootherBase_smoothArch" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbsMarginalSmootherBase_smoothArch" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg2 = ptr;
	}
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbsMarginalSmootherBase_smoothArch" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbsMarginalSmootherBase_smoothArch" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	- result = (arg1)->SWIGTEMPLATEDISAMBIGUATOR smoothArch< std::vector< double > >((std::vector< double,std::allocator< double > > const &)*arg2,arg3,arg4,arg5);
	+ result = (npstat::HistoND< double,npstat::HistoAxis > )(arg1)->SWIGTEMPLATEDISAMBIGUATOR smoothArch< std::vector< double > >((std::vector< double,std::allocator< double > > const &)arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	- resultobj = SWIG_NewPointerObj((new npstat::HistoND< double >(static_cast< const npstat::HistoND< double >& >(result))), SWIGTYPE_p_npstat__HistoNDT_double_t, SWIG_POINTER_OWN \| 0 );
	+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsTmpObj(res5)) {
	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
	} else {
	int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN \| 0 ) : 0 ;
	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
	}
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsMarginalSmootherBase_weightedSmoothArch(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsMarginalSmootherBase arg1 = (npstat::AbsMarginalSmootherBase ) 0 ;
	std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *arg2 = 0 ;
	unsigned long arg3 ;
	unsigned int arg4 ;
	double arg5 = (double ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	double temp5 ;
	int res5 = SWIG_TMPOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	- SwigValueWrapper< npstat::HistoND< double > > result;
	+ npstat::HistoND< double,npstat::HistoAxis > *result = 0 ;

	arg5 = &temp5;
	if (!PyArg_ParseTuple(args,(char *)"OOOO:AbsMarginalSmootherBase_weightedSmoothArch",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsMarginalSmootherBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsMarginalSmootherBase_weightedSmoothArch" "', argument " "1"" of type '" "npstat::AbsMarginalSmootherBase *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsMarginalSmootherBase * >(argp1);
	{
	std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > ptr = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbsMarginalSmootherBase_weightedSmoothArch" "', argument " "2"" of type '" "std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbsMarginalSmootherBase_weightedSmoothArch" "', argument " "2"" of type '" "std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &""'");
	}
	arg2 = ptr;
	}
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbsMarginalSmootherBase_weightedSmoothArch" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbsMarginalSmootherBase_weightedSmoothArch" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	- result = (arg1)->SWIGTEMPLATEDISAMBIGUATOR weightedSmoothArch< std::vector< std::pair< double,double > > >((std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)*arg2,arg3,arg4,arg5);
	+ result = (npstat::HistoND< double,npstat::HistoAxis > )(arg1)->SWIGTEMPLATEDISAMBIGUATOR weightedSmoothArch< std::vector< std::pair< double,double > > >((std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > const &)arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	- resultobj = SWIG_NewPointerObj((new npstat::HistoND< double >(static_cast< const npstat::HistoND< double >& >(result))), SWIGTYPE_p_npstat__HistoNDT_double_t, SWIG_POINTER_OWN \| 0 );
	+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsTmpObj(res5)) {
	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
	} else {
	int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN \| 0 ) : 0 ;
	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
	}
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject AbsMarginalSmootherBase_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsMarginalSmootherBase, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ConstantBandwidthSmoother1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	double arg2 ;
	double arg3 ;
	int arg4 ;
	unsigned int arg5 ;
	double arg6 ;
	double arg7 ;
	bool arg8 ;
	char arg9 = (char ) 0 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	double val7 ;
	int ecode7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	int res9 ;
	char *buf9 = 0 ;
	int alloc9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	npstat::ConstantBandwidthSmoother1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:new_ConstantBandwidthSmoother1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "4"" of type '" "int""'");
	}
	arg4 = static_cast< int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	ecode7 = SWIG_AsVal_double(obj6, &val7);
	if (!SWIG_IsOK(ecode7)) {
	SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "7"" of type '" "double""'");
	}
	arg7 = static_cast< double >(val7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	res9 = SWIG_AsCharPtrAndSize(obj8, &buf9, NULL, &alloc9);
	if (!SWIG_IsOK(res9)) {
	SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "9"" of type '" "char const *""'");
	}
	arg9 = reinterpret_cast< char * >(buf9);
	{
	try {
	result = (npstat::ConstantBandwidthSmoother1D )new npstat::ConstantBandwidthSmoother1D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(char const )arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConstantBandwidthSmoother1D, SWIG_POINTER_NEW \| 0 );
	if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
	return resultobj;
	fail:
	if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConstantBandwidthSmoother1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	double arg2 ;
	double arg3 ;
	int arg4 ;
	unsigned int arg5 ;
	double arg6 ;
	double arg7 ;
	bool arg8 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	double val7 ;
	int ecode7 = 0 ;
	bool val8 ;
	int ecode8 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	npstat::ConstantBandwidthSmoother1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:new_ConstantBandwidthSmoother1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "4"" of type '" "int""'");
	}
	arg4 = static_cast< int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	ecode7 = SWIG_AsVal_double(obj6, &val7);
	if (!SWIG_IsOK(ecode7)) {
	SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "7"" of type '" "double""'");
	}
	arg7 = static_cast< double >(val7);
	ecode8 = SWIG_AsVal_bool(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "8"" of type '" "bool""'");
	}
	arg8 = static_cast< bool >(val8);
	{
	try {
	result = (npstat::ConstantBandwidthSmoother1D *)new npstat::ConstantBandwidthSmoother1D(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConstantBandwidthSmoother1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConstantBandwidthSmoother1D__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	double arg2 ;
	double arg3 ;
	int arg4 ;
	unsigned int arg5 ;
	double arg6 ;
	double arg7 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	double val7 ;
	int ecode7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	npstat::ConstantBandwidthSmoother1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:new_ConstantBandwidthSmoother1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "4"" of type '" "int""'");
	}
	arg4 = static_cast< int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	ecode7 = SWIG_AsVal_double(obj6, &val7);
	if (!SWIG_IsOK(ecode7)) {
	SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "7"" of type '" "double""'");
	}
	arg7 = static_cast< double >(val7);
	{
	try {
	result = (npstat::ConstantBandwidthSmoother1D *)new npstat::ConstantBandwidthSmoother1D(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConstantBandwidthSmoother1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConstantBandwidthSmoother1D__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	double arg2 ;
	double arg3 ;
	int arg4 ;
	unsigned int arg5 ;
	double arg6 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	npstat::ConstantBandwidthSmoother1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_ConstantBandwidthSmoother1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "4"" of type '" "int""'");
	}
	arg4 = static_cast< int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	try {
	result = (npstat::ConstantBandwidthSmoother1D *)new npstat::ConstantBandwidthSmoother1D(arg1,arg2,arg3,arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConstantBandwidthSmoother1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConstantBandwidthSmoother1D__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	double arg2 ;
	double arg3 ;
	int arg4 ;
	unsigned int arg5 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	npstat::ConstantBandwidthSmoother1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_ConstantBandwidthSmoother1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "4"" of type '" "int""'");
	}
	arg4 = static_cast< int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ConstantBandwidthSmoother1D" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	result = (npstat::ConstantBandwidthSmoother1D *)new npstat::ConstantBandwidthSmoother1D(arg1,arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConstantBandwidthSmoother1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConstantBandwidthSmoother1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[10] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 9) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 5) {
	int _v;
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConstantBandwidthSmoother1D__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConstantBandwidthSmoother1D__SWIG_3(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[6], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConstantBandwidthSmoother1D__SWIG_2(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 8) {
	int _v;
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[6], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConstantBandwidthSmoother1D__SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 9) {
	int _v;
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[6], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[8], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_ConstantBandwidthSmoother1D__SWIG_0(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ConstantBandwidthSmoother1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ConstantBandwidthSmoother1D::ConstantBandwidthSmoother1D(unsigned int,double,double,int,unsigned int,double,double,bool,char const *)\n"
	" npstat::ConstantBandwidthSmoother1D::ConstantBandwidthSmoother1D(unsigned int,double,double,int,unsigned int,double,double,bool)\n"
	" npstat::ConstantBandwidthSmoother1D::ConstantBandwidthSmoother1D(unsigned int,double,double,int,unsigned int,double,double)\n"
	" npstat::ConstantBandwidthSmoother1D::ConstantBandwidthSmoother1D(unsigned int,double,double,int,unsigned int,double)\n"
	" npstat::ConstantBandwidthSmoother1D::ConstantBandwidthSmoother1D(unsigned int,double,double,int,unsigned int)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_ConstantBandwidthSmoother1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmoother1D arg1 = (npstat::ConstantBandwidthSmoother1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ConstantBandwidthSmoother1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmoother1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstantBandwidthSmoother1D" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmoother1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmoother1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmoother1D_symbetaPower(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmoother1D arg1 = (npstat::ConstantBandwidthSmoother1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	int result;

	if (!PyArg_ParseTuple(args,(char *)"O:ConstantBandwidthSmoother1D_symbetaPower",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmoother1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmoother1D_symbetaPower" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmoother1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmoother1D * >(argp1);
	{
	try {
	result = (int)((npstat::ConstantBandwidthSmoother1D const *)arg1)->symbetaPower();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_int(static_cast< int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmoother1D_kernelOrder(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmoother1D arg1 = (npstat::ConstantBandwidthSmoother1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:ConstantBandwidthSmoother1D_kernelOrder",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmoother1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmoother1D_kernelOrder" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmoother1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmoother1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::ConstantBandwidthSmoother1D const *)arg1)->kernelOrder();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmoother1D_fixedBandwidth(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmoother1D arg1 = (npstat::ConstantBandwidthSmoother1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:ConstantBandwidthSmoother1D_fixedBandwidth",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmoother1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmoother1D_fixedBandwidth" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmoother1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmoother1D * >(argp1);
	{
	try {
	result = (double)((npstat::ConstantBandwidthSmoother1D const *)arg1)->fixedBandwidth();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmoother1D_bwFactor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmoother1D arg1 = (npstat::ConstantBandwidthSmoother1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:ConstantBandwidthSmoother1D_bwFactor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmoother1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmoother1D_bwFactor" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmoother1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmoother1D * >(argp1);
	{
	try {
	result = (double)((npstat::ConstantBandwidthSmoother1D const *)arg1)->bwFactor();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmoother1D_mirrorsData(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmoother1D arg1 = (npstat::ConstantBandwidthSmoother1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:ConstantBandwidthSmoother1D_mirrorsData",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmoother1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmoother1D_mirrorsData" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmoother1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmoother1D * >(argp1);
	{
	try {
	result = (bool)((npstat::ConstantBandwidthSmoother1D const *)arg1)->mirrorsData();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmoother1D_dataLen(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmoother1D arg1 = (npstat::ConstantBandwidthSmoother1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:ConstantBandwidthSmoother1D_dataLen",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmoother1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmoother1D_dataLen" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmoother1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmoother1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::ConstantBandwidthSmoother1D const *)arg1)->dataLen();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConstantBandwidthSmoother1D_selfContribution(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConstantBandwidthSmoother1D arg1 = (npstat::ConstantBandwidthSmoother1D ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:ConstantBandwidthSmoother1D_selfContribution",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConstantBandwidthSmoother1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantBandwidthSmoother1D_selfContribution" "', argument " "1"" of type '" "npstat::ConstantBandwidthSmoother1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConstantBandwidthSmoother1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstantBandwidthSmoother1D_selfContribution" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (double)((npstat::ConstantBandwidthSmoother1D const *)arg1)->selfContribution(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ConstantBandwidthSmoother1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ConstantBandwidthSmoother1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_CompositeDistribution1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistribution1D *arg1 = 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::CompositeDistribution1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_CompositeDistribution1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CompositeDistribution1D" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CompositeDistribution1D" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistribution1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CompositeDistribution1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CompositeDistribution1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	{
	try {
	result = (npstat::CompositeDistribution1D )new npstat::CompositeDistribution1D((npstat::AbsDistribution1D const &)arg1,(npstat::AbsDistribution1D const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__CompositeDistribution1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_CompositeDistribution1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::CompositeDistribution1D *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::CompositeDistribution1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_CompositeDistribution1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__CompositeDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CompositeDistribution1D" "', argument " "1"" of type '" "npstat::CompositeDistribution1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CompositeDistribution1D" "', argument " "1"" of type '" "npstat::CompositeDistribution1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::CompositeDistribution1D * >(argp1);
	{
	try {
	result = (npstat::CompositeDistribution1D )new npstat::CompositeDistribution1D((npstat::CompositeDistribution1D const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__CompositeDistribution1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_CompositeDistribution1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__CompositeDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_CompositeDistribution1D__SWIG_1(self, args);
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_CompositeDistribution1D__SWIG_0(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_CompositeDistribution1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::CompositeDistribution1D::CompositeDistribution1D(npstat::AbsDistribution1D const &,npstat::AbsDistribution1D const &)\n"
	" npstat::CompositeDistribution1D::CompositeDistribution1D(npstat::CompositeDistribution1D const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_CompositeDistribution1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::CompositeDistribution1D arg1 = (npstat::CompositeDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_CompositeDistribution1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__CompositeDistribution1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CompositeDistribution1D" "', argument " "1"" of type '" "npstat::CompositeDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::CompositeDistribution1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_CompositeDistribution1D_density(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::CompositeDistribution1D arg1 = (npstat::CompositeDistribution1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:CompositeDistribution1D_density",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__CompositeDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositeDistribution1D_density" "', argument " "1"" of type '" "npstat::CompositeDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::CompositeDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CompositeDistribution1D_density" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::CompositeDistribution1D const *)arg1)->density(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_CompositeDistribution1D_cdf(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::CompositeDistribution1D arg1 = (npstat::CompositeDistribution1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:CompositeDistribution1D_cdf",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__CompositeDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositeDistribution1D_cdf" "', argument " "1"" of type '" "npstat::CompositeDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::CompositeDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CompositeDistribution1D_cdf" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::CompositeDistribution1D const *)arg1)->cdf(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_CompositeDistribution1D_exceedance(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::CompositeDistribution1D arg1 = (npstat::CompositeDistribution1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:CompositeDistribution1D_exceedance",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__CompositeDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositeDistribution1D_exceedance" "', argument " "1"" of type '" "npstat::CompositeDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::CompositeDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CompositeDistribution1D_exceedance" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::CompositeDistribution1D const *)arg1)->exceedance(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_CompositeDistribution1D_quantile(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::CompositeDistribution1D arg1 = (npstat::CompositeDistribution1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:CompositeDistribution1D_quantile",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__CompositeDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositeDistribution1D_quantile" "', argument " "1"" of type '" "npstat::CompositeDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::CompositeDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CompositeDistribution1D_quantile" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::CompositeDistribution1D const *)arg1)->quantile(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_CompositeDistribution1D_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::CompositeDistribution1D arg1 = (npstat::CompositeDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::CompositeDistribution1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:CompositeDistribution1D_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__CompositeDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositeDistribution1D_clone" "', argument " "1"" of type '" "npstat::CompositeDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::CompositeDistribution1D * >(argp1);
	{
	try {
	result = (npstat::CompositeDistribution1D )((npstat::CompositeDistribution1D const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__CompositeDistribution1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_CompositeDistribution1D_G(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::CompositeDistribution1D arg1 = (npstat::CompositeDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::AbsDistribution1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:CompositeDistribution1D_G",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__CompositeDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositeDistribution1D_G" "', argument " "1"" of type '" "npstat::CompositeDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::CompositeDistribution1D * >(argp1);
	{
	try {
	result = (npstat::AbsDistribution1D ) &((npstat::CompositeDistribution1D const )arg1)->G();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_CompositeDistribution1D_H(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::CompositeDistribution1D arg1 = (npstat::CompositeDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::AbsDistribution1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:CompositeDistribution1D_H",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__CompositeDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositeDistribution1D_H" "', argument " "1"" of type '" "npstat::CompositeDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::CompositeDistribution1D * >(argp1);
	{
	try {
	result = (npstat::AbsDistribution1D ) &((npstat::CompositeDistribution1D const )arg1)->H();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_CompositeDistribution1D_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::CompositeDistribution1D arg1 = (npstat::CompositeDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:CompositeDistribution1D_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__CompositeDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositeDistribution1D_classId" "', argument " "1"" of type '" "npstat::CompositeDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::CompositeDistribution1D * >(argp1);
	{
	try {
	result = ((npstat::CompositeDistribution1D const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_CompositeDistribution1D_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::CompositeDistribution1D arg1 = (npstat::CompositeDistribution1D ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:CompositeDistribution1D_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__CompositeDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositeDistribution1D_write" "', argument " "1"" of type '" "npstat::CompositeDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::CompositeDistribution1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CompositeDistribution1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CompositeDistribution1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::CompositeDistribution1D const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_CompositeDistribution1D_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":CompositeDistribution1D_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::CompositeDistribution1D::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_CompositeDistribution1D_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":CompositeDistribution1D_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::CompositeDistribution1D::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_CompositeDistribution1D_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::CompositeDistribution1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:CompositeDistribution1D_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositeDistribution1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CompositeDistribution1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CompositeDistribution1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CompositeDistribution1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::CompositeDistribution1D )npstat::CompositeDistribution1D::read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__CompositeDistribution1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject CompositeDistribution1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__CompositeDistribution1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DoubleKDE1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsKDE1DKernel *arg1 = 0 ;
	double arg2 = (double ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::KDE1D< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DoubleKDE1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsKDE1DKernel, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleKDE1D" "', argument " "1"" of type '" "npstat::AbsKDE1DKernel const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleKDE1D" "', argument " "1"" of type '" "npstat::AbsKDE1DKernel const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsKDE1DKernel * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleKDE1D" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleKDE1D" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	result = (npstat::KDE1D< double > )new npstat::KDE1D< double >((npstat::AbsKDE1DKernel const &)arg1,(double const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__KDE1DT_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleKDE1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsKDE1DKernel *arg1 = 0 ;
	std::vector< double,std::allocator< double > > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::KDE1D< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_DoubleKDE1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsKDE1DKernel, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleKDE1D" "', argument " "1"" of type '" "npstat::AbsKDE1DKernel const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleKDE1D" "', argument " "1"" of type '" "npstat::AbsKDE1DKernel const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsKDE1DKernel * >(argp1);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleKDE1D" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleKDE1D" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg2 = ptr;
	}
	{
	try {
	result = (npstat::KDE1D< double > )new npstat::KDE1D< double >((npstat::AbsKDE1DKernel const &)arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__KDE1DT_double_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleKDE1D__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1D< double > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::KDE1D< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_DoubleKDE1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__KDE1DT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleKDE1D" "', argument " "1"" of type '" "npstat::KDE1D< double > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleKDE1D" "', argument " "1"" of type '" "npstat::KDE1D< double > const &""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1D< double > * >(argp1);
	{
	try {
	result = (npstat::KDE1D< double > )new npstat::KDE1D< double >((npstat::KDE1D< double > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__KDE1DT_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleKDE1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__KDE1DT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleKDE1D__SWIG_2(self, args);
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsKDE1DKernel, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleKDE1D__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsKDE1DKernel, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleKDE1D__SWIG_0(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DoubleKDE1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::KDE1D< double >::KDE1D(npstat::AbsKDE1DKernel const &,double const *,unsigned long const)\n"
	" npstat::KDE1D< double >::KDE1D(npstat::AbsKDE1DKernel const &,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::KDE1D< double >::KDE1D(npstat::KDE1D< double > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_DoubleKDE1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1D< double > arg1 = (npstat::KDE1D< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleKDE1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DT_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleKDE1D" "', argument " "1"" of type '" "npstat::KDE1D< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1D< double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleKDE1D_kernel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1D< double > arg1 = (npstat::KDE1D< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::AbsKDE1DKernel *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleKDE1D_kernel",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleKDE1D_kernel" "', argument " "1"" of type '" "npstat::KDE1D< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1D< double > * >(argp1);
	{
	try {
	result = (npstat::AbsKDE1DKernel ) &((npstat::KDE1D< double > const )arg1)->kernel();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__AbsKDE1DKernel, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleKDE1D_coords(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1D< double > arg1 = (npstat::KDE1D< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< double,std::allocator< double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleKDE1D_coords",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleKDE1D_coords" "', argument " "1"" of type '" "npstat::KDE1D< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1D< double > * >(argp1);
	{
	try {
	result = (std::vector< double,std::allocator< double > > ) &((npstat::KDE1D< double > const )arg1)->coords();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleKDE1D_nCoords(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1D< double > arg1 = (npstat::KDE1D< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleKDE1D_nCoords",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleKDE1D_nCoords" "', argument " "1"" of type '" "npstat::KDE1D< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1D< double > * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::KDE1D< double > const *)arg1)->nCoords();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleKDE1D_minCoordinate(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1D< double > arg1 = (npstat::KDE1D< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleKDE1D_minCoordinate",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleKDE1D_minCoordinate" "', argument " "1"" of type '" "npstat::KDE1D< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1D< double > * >(argp1);
	{
	try {
	result = (double)((npstat::KDE1D< double > const *)arg1)->minCoordinate();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleKDE1D_maxCoordinate(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1D< double > arg1 = (npstat::KDE1D< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleKDE1D_maxCoordinate",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleKDE1D_maxCoordinate" "', argument " "1"" of type '" "npstat::KDE1D< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1D< double > * >(argp1);
	{
	try {
	result = (double)((npstat::KDE1D< double > const *)arg1)->maxCoordinate();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleKDE1D_density(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1D< double > arg1 = (npstat::KDE1D< double > ) 0 ;
	double arg2 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleKDE1D_density",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleKDE1D_density" "', argument " "1"" of type '" "npstat::KDE1D< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1D< double > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleKDE1D_density" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleKDE1D_density" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (double)((npstat::KDE1D< double > const *)arg1)->density(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleKDE1D_densityFunctor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1D< double > arg1 = (npstat::KDE1D< double > ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	SwigValueWrapper< npstat::KDE1DFunctorHelper< double > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleKDE1D_densityFunctor",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleKDE1D_densityFunctor" "', argument " "1"" of type '" "npstat::KDE1D< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1D< double > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleKDE1D_densityFunctor" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = ((npstat::KDE1D< double > const *)arg1)->densityFunctor(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::KDE1DFunctorHelper< double >(static_cast< const npstat::KDE1DFunctorHelper< double >& >(result))), SWIGTYPE_p_npstat__KDE1DFunctorHelperT_double_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleKDE1D_rlcvFunctor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1D< double > arg1 = (npstat::KDE1D< double > ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	SwigValueWrapper< npstat::KDE1DRLCVFunctorHelper< double > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleKDE1D_rlcvFunctor",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleKDE1D_rlcvFunctor" "', argument " "1"" of type '" "npstat::KDE1D< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1D< double > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleKDE1D_rlcvFunctor" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = ((npstat::KDE1D< double > const *)arg1)->rlcvFunctor(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::KDE1DRLCVFunctorHelper< double >(static_cast< const npstat::KDE1DRLCVFunctorHelper< double >& >(result))), SWIGTYPE_p_npstat__KDE1DRLCVFunctorHelperT_double_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleKDE1D_lscvFunctor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1D< double > arg1 = (npstat::KDE1D< double > ) 0 ;
	double arg2 ;
	double arg3 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	SwigValueWrapper< npstat::KDE1DLSCVFunctorHelper< double > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:DoubleKDE1D_lscvFunctor",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleKDE1D_lscvFunctor" "', argument " "1"" of type '" "npstat::KDE1D< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1D< double > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleKDE1D_lscvFunctor" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleKDE1D_lscvFunctor" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleKDE1D_lscvFunctor" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoubleKDE1D_lscvFunctor" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	result = ((npstat::KDE1D< double > const *)arg1)->lscvFunctor(arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::KDE1DLSCVFunctorHelper< double >(static_cast< const npstat::KDE1DLSCVFunctorHelper< double >& >(result))), SWIGTYPE_p_npstat__KDE1DLSCVFunctorHelperT_double_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleKDE1D_integratedSquaredError(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1D< double > arg1 = (npstat::KDE1D< double > ) 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	double arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:DoubleKDE1D_integratedSquaredError",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleKDE1D_integratedSquaredError" "', argument " "1"" of type '" "npstat::KDE1D< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1D< double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleKDE1D_integratedSquaredError" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleKDE1D_integratedSquaredError" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleKDE1D_integratedSquaredError" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleKDE1D_integratedSquaredError" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoubleKDE1D_integratedSquaredError" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	{
	try {
	result = (double)((npstat::KDE1D< double > const )arg1)->integratedSquaredError((npstat::AbsDistribution1D const &)arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleKDE1D_rlcv(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1D< double > arg1 = (npstat::KDE1D< double > ) 0 ;
	double arg2 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleKDE1D_rlcv",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleKDE1D_rlcv" "', argument " "1"" of type '" "npstat::KDE1D< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1D< double > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleKDE1D_rlcv" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleKDE1D_rlcv" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (double)((npstat::KDE1D< double > const *)arg1)->rlcv(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleKDE1D_lscv(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1D< double > arg1 = (npstat::KDE1D< double > ) 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	unsigned int arg5 ;
	unsigned int arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:DoubleKDE1D_lscv",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__KDE1DT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleKDE1D_lscv" "', argument " "1"" of type '" "npstat::KDE1D< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1D< double > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleKDE1D_lscv" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleKDE1D_lscv" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleKDE1D_lscv" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoubleKDE1D_lscv" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DoubleKDE1D_lscv" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	{
	try {
	result = (double)((npstat::KDE1D< double > const *)arg1)->lscv(arg2,arg3,arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleKDE1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__KDE1DT_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_WeightedStatAccumulatorPair(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_WeightedStatAccumulatorPair")) SWIG_fail;
	{
	try {
	result = (npstat::WeightedStatAccumulatorPair *)new npstat::WeightedStatAccumulatorPair();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_first(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::WeightedStatAccumulator *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:WeightedStatAccumulatorPair_first",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair_first" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair const *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	{
	try {
	result = (npstat::WeightedStatAccumulator ) &((npstat::WeightedStatAccumulatorPair const )arg1)->first();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__WeightedStatAccumulator, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_second(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::WeightedStatAccumulator *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:WeightedStatAccumulatorPair_second",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair_second" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair const *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	{
	try {
	result = (npstat::WeightedStatAccumulator ) &((npstat::WeightedStatAccumulatorPair const )arg1)->second();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__WeightedStatAccumulator, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_crossSumsq(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	long double result;

	if (!PyArg_ParseTuple(args,(char *)"O:WeightedStatAccumulatorPair_crossSumsq",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair_crossSumsq" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair const *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	{
	try {
	result = (long double)((npstat::WeightedStatAccumulatorPair const *)arg1)->crossSumsq();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new long double(static_cast< const long double& >(result))), SWIGTYPE_p_long_double, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_count(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:WeightedStatAccumulatorPair_count",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair_count" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair const *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	{
	try {
	result = (double)((npstat::WeightedStatAccumulatorPair const *)arg1)->count();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_ncalls(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:WeightedStatAccumulatorPair_ncalls",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair_ncalls" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair const *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::WeightedStatAccumulatorPair const *)arg1)->ncalls();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_nfills(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:WeightedStatAccumulatorPair_nfills",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair_nfills" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair const *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::WeightedStatAccumulatorPair const *)arg1)->nfills();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_cov(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:WeightedStatAccumulatorPair_cov",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair_cov" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair const *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	{
	try {
	result = (double)((npstat::WeightedStatAccumulatorPair const *)arg1)->cov();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_corr(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:WeightedStatAccumulatorPair_corr",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair_corr" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair const *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	{
	try {
	result = (double)((npstat::WeightedStatAccumulatorPair const *)arg1)->corr();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_accumulate__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:WeightedStatAccumulatorPair_accumulate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair_accumulate" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedStatAccumulatorPair_accumulate" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "WeightedStatAccumulatorPair_accumulate" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "WeightedStatAccumulatorPair_accumulate" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	(arg1)->accumulate(arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_accumulate__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	std::pair< double,double > *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:WeightedStatAccumulatorPair_accumulate",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair_accumulate" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	{
	std::pair< double,double > ptr = (std::pair< double,double > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedStatAccumulatorPair_accumulate" "', argument " "2"" of type '" "std::pair< double,double > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedStatAccumulatorPair_accumulate" "', argument " "2"" of type '" "std::pair< double,double > const &""'");
	}
	arg2 = ptr;
	}
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "WeightedStatAccumulatorPair_accumulate" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	(arg1)->accumulate((std::pair< double,double > const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_accumulate__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	npstat::WeightedStatAccumulatorPair *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:WeightedStatAccumulatorPair_accumulate",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair_accumulate" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedStatAccumulatorPair_accumulate" "', argument " "2"" of type '" "npstat::WeightedStatAccumulatorPair const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedStatAccumulatorPair_accumulate" "', argument " "2"" of type '" "npstat::WeightedStatAccumulatorPair const &""'");
	}
	arg2 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp2);
	{
	try {
	(arg1)->accumulate((npstat::WeightedStatAccumulatorPair const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_accumulate__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	npstat::WeightedStatAccumulatorPair *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:WeightedStatAccumulatorPair_accumulate",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair_accumulate" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedStatAccumulatorPair_accumulate" "', argument " "2"" of type '" "npstat::WeightedStatAccumulatorPair const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedStatAccumulatorPair_accumulate" "', argument " "2"" of type '" "npstat::WeightedStatAccumulatorPair const &""'");
	}
	arg2 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "WeightedStatAccumulatorPair_accumulate" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	(arg1)->accumulate((npstat::WeightedStatAccumulatorPair const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_accumulate(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_WeightedStatAccumulatorPair_accumulate__SWIG_2(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_WeightedStatAccumulatorPair_accumulate__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[1], (std::pair< double,double >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_WeightedStatAccumulatorPair_accumulate__SWIG_1(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_WeightedStatAccumulatorPair_accumulate__SWIG_0(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'WeightedStatAccumulatorPair_accumulate'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::WeightedStatAccumulatorPair::accumulate(double,double,double)\n"
	" npstat::WeightedStatAccumulatorPair::accumulate(std::pair< double,double > const &,double)\n"
	" npstat::WeightedStatAccumulatorPair::accumulate(npstat::WeightedStatAccumulatorPair const &)\n"
	" npstat::WeightedStatAccumulatorPair::accumulate(npstat::WeightedStatAccumulatorPair const &,double)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_reset(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:WeightedStatAccumulatorPair_reset",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair_reset" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	{
	try {
	(arg1)->reset();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair___iadd__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	npstat::WeightedStatAccumulatorPair *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::WeightedStatAccumulatorPair *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:WeightedStatAccumulatorPair___iadd__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair___iadd__" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedStatAccumulatorPair___iadd__" "', argument " "2"" of type '" "npstat::WeightedStatAccumulatorPair const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedStatAccumulatorPair___iadd__" "', argument " "2"" of type '" "npstat::WeightedStatAccumulatorPair const &""'");
	}
	arg2 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp2);
	{
	try {
	result = (npstat::WeightedStatAccumulatorPair ) &(arg1)->operator +=((npstat::WeightedStatAccumulatorPair const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_scaleWeights(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::WeightedStatAccumulatorPair *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:WeightedStatAccumulatorPair_scaleWeights",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair_scaleWeights" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "WeightedStatAccumulatorPair_scaleWeights" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (npstat::WeightedStatAccumulatorPair *) &(arg1)->scaleWeights(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair___eq__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	npstat::WeightedStatAccumulatorPair *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:WeightedStatAccumulatorPair___eq__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair___eq__" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair const *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedStatAccumulatorPair___eq__" "', argument " "2"" of type '" "npstat::WeightedStatAccumulatorPair const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedStatAccumulatorPair___eq__" "', argument " "2"" of type '" "npstat::WeightedStatAccumulatorPair const &""'");
	}
	arg2 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp2);
	{
	try {
	result = (bool)((npstat::WeightedStatAccumulatorPair const )arg1)->operator ==((npstat::WeightedStatAccumulatorPair const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair___ne__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	npstat::WeightedStatAccumulatorPair *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:WeightedStatAccumulatorPair___ne__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair___ne__" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair const *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedStatAccumulatorPair___ne__" "', argument " "2"" of type '" "npstat::WeightedStatAccumulatorPair const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedStatAccumulatorPair___ne__" "', argument " "2"" of type '" "npstat::WeightedStatAccumulatorPair const &""'");
	}
	arg2 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp2);
	{
	try {
	result = (bool)((npstat::WeightedStatAccumulatorPair const )arg1)->operator !=((npstat::WeightedStatAccumulatorPair const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:WeightedStatAccumulatorPair_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair_classId" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair const *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	{
	try {
	result = ((npstat::WeightedStatAccumulatorPair const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:WeightedStatAccumulatorPair_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair_write" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair const *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedStatAccumulatorPair_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedStatAccumulatorPair_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::WeightedStatAccumulatorPair const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":WeightedStatAccumulatorPair_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::WeightedStatAccumulatorPair::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":WeightedStatAccumulatorPair_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::WeightedStatAccumulatorPair::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_WeightedStatAccumulatorPair_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	npstat::WeightedStatAccumulatorPair arg3 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:WeightedStatAccumulatorPair_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WeightedStatAccumulatorPair_restore" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedStatAccumulatorPair_restore" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WeightedStatAccumulatorPair_restore" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WeightedStatAccumulatorPair_restore" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WeightedStatAccumulatorPair_restore" "', argument " "3"" of type '" "npstat::WeightedStatAccumulatorPair *""'");
	}
	arg3 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp3);
	{
	try {
	npstat::WeightedStatAccumulatorPair::restore((gs::ClassId const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_WeightedStatAccumulatorPair(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::WeightedStatAccumulatorPair arg1 = (npstat::WeightedStatAccumulatorPair ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_WeightedStatAccumulatorPair",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WeightedStatAccumulatorPair" "', argument " "1"" of type '" "npstat::WeightedStatAccumulatorPair *""'");
	}
	arg1 = reinterpret_cast< npstat::WeightedStatAccumulatorPair * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject WeightedStatAccumulatorPair_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__WeightedStatAccumulatorPair, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_LeftCensoredDistribution__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistribution1D *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::LeftCensoredDistribution *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_LeftCensoredDistribution",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LeftCensoredDistribution" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LeftCensoredDistribution" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LeftCensoredDistribution" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LeftCensoredDistribution" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (npstat::LeftCensoredDistribution )new npstat::LeftCensoredDistribution((npstat::AbsDistribution1D const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LeftCensoredDistribution, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LeftCensoredDistribution__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LeftCensoredDistribution *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::LeftCensoredDistribution *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_LeftCensoredDistribution",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__LeftCensoredDistribution, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LeftCensoredDistribution" "', argument " "1"" of type '" "npstat::LeftCensoredDistribution const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LeftCensoredDistribution" "', argument " "1"" of type '" "npstat::LeftCensoredDistribution const &""'");
	}
	arg1 = reinterpret_cast< npstat::LeftCensoredDistribution * >(argp1);
	{
	try {
	result = (npstat::LeftCensoredDistribution )new npstat::LeftCensoredDistribution((npstat::LeftCensoredDistribution const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LeftCensoredDistribution, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LeftCensoredDistribution(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__LeftCensoredDistribution, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_LeftCensoredDistribution__SWIG_1(self, args);
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_LeftCensoredDistribution__SWIG_0(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LeftCensoredDistribution'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LeftCensoredDistribution::LeftCensoredDistribution(npstat::AbsDistribution1D const &,double,double)\n"
	" npstat::LeftCensoredDistribution::LeftCensoredDistribution(npstat::LeftCensoredDistribution const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_LeftCensoredDistribution_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LeftCensoredDistribution arg1 = (npstat::LeftCensoredDistribution ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::LeftCensoredDistribution *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LeftCensoredDistribution_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LeftCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeftCensoredDistribution_clone" "', argument " "1"" of type '" "npstat::LeftCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::LeftCensoredDistribution * >(argp1);
	{
	try {
	result = (npstat::LeftCensoredDistribution )((npstat::LeftCensoredDistribution const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LeftCensoredDistribution, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_LeftCensoredDistribution(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LeftCensoredDistribution arg1 = (npstat::LeftCensoredDistribution ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LeftCensoredDistribution",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LeftCensoredDistribution, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LeftCensoredDistribution" "', argument " "1"" of type '" "npstat::LeftCensoredDistribution *""'");
	}
	arg1 = reinterpret_cast< npstat::LeftCensoredDistribution * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LeftCensoredDistribution_visible(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LeftCensoredDistribution arg1 = (npstat::LeftCensoredDistribution ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::AbsDistribution1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LeftCensoredDistribution_visible",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LeftCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeftCensoredDistribution_visible" "', argument " "1"" of type '" "npstat::LeftCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::LeftCensoredDistribution * >(argp1);
	{
	try {
	result = (npstat::AbsDistribution1D ) &((npstat::LeftCensoredDistribution const )arg1)->visible();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LeftCensoredDistribution_visibleFraction(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LeftCensoredDistribution arg1 = (npstat::LeftCensoredDistribution ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:LeftCensoredDistribution_visibleFraction",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LeftCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeftCensoredDistribution_visibleFraction" "', argument " "1"" of type '" "npstat::LeftCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::LeftCensoredDistribution * >(argp1);
	{
	try {
	result = (double)((npstat::LeftCensoredDistribution const *)arg1)->visibleFraction();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LeftCensoredDistribution_effectiveInfinity(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LeftCensoredDistribution arg1 = (npstat::LeftCensoredDistribution ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:LeftCensoredDistribution_effectiveInfinity",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LeftCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeftCensoredDistribution_effectiveInfinity" "', argument " "1"" of type '" "npstat::LeftCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::LeftCensoredDistribution * >(argp1);
	{
	try {
	result = (double)((npstat::LeftCensoredDistribution const *)arg1)->effectiveInfinity();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LeftCensoredDistribution_density(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LeftCensoredDistribution arg1 = (npstat::LeftCensoredDistribution ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:LeftCensoredDistribution_density",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LeftCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeftCensoredDistribution_density" "', argument " "1"" of type '" "npstat::LeftCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::LeftCensoredDistribution * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LeftCensoredDistribution_density" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::LeftCensoredDistribution const *)arg1)->density(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LeftCensoredDistribution_cdf(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LeftCensoredDistribution arg1 = (npstat::LeftCensoredDistribution ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:LeftCensoredDistribution_cdf",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LeftCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeftCensoredDistribution_cdf" "', argument " "1"" of type '" "npstat::LeftCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::LeftCensoredDistribution * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LeftCensoredDistribution_cdf" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::LeftCensoredDistribution const *)arg1)->cdf(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LeftCensoredDistribution_exceedance(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LeftCensoredDistribution arg1 = (npstat::LeftCensoredDistribution ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:LeftCensoredDistribution_exceedance",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LeftCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeftCensoredDistribution_exceedance" "', argument " "1"" of type '" "npstat::LeftCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::LeftCensoredDistribution * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LeftCensoredDistribution_exceedance" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::LeftCensoredDistribution const *)arg1)->exceedance(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LeftCensoredDistribution_quantile(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LeftCensoredDistribution arg1 = (npstat::LeftCensoredDistribution ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:LeftCensoredDistribution_quantile",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LeftCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeftCensoredDistribution_quantile" "', argument " "1"" of type '" "npstat::LeftCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::LeftCensoredDistribution * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LeftCensoredDistribution_quantile" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::LeftCensoredDistribution const *)arg1)->quantile(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LeftCensoredDistribution_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LeftCensoredDistribution arg1 = (npstat::LeftCensoredDistribution ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:LeftCensoredDistribution_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LeftCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeftCensoredDistribution_classId" "', argument " "1"" of type '" "npstat::LeftCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::LeftCensoredDistribution * >(argp1);
	{
	try {
	result = ((npstat::LeftCensoredDistribution const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LeftCensoredDistribution_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LeftCensoredDistribution arg1 = (npstat::LeftCensoredDistribution ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:LeftCensoredDistribution_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LeftCensoredDistribution, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeftCensoredDistribution_write" "', argument " "1"" of type '" "npstat::LeftCensoredDistribution const *""'");
	}
	arg1 = reinterpret_cast< npstat::LeftCensoredDistribution * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LeftCensoredDistribution_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LeftCensoredDistribution_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::LeftCensoredDistribution const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LeftCensoredDistribution_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":LeftCensoredDistribution_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::LeftCensoredDistribution::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LeftCensoredDistribution_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":LeftCensoredDistribution_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::LeftCensoredDistribution::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LeftCensoredDistribution_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LeftCensoredDistribution *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LeftCensoredDistribution_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeftCensoredDistribution_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LeftCensoredDistribution_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LeftCensoredDistribution_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LeftCensoredDistribution_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::LeftCensoredDistribution )npstat::LeftCensoredDistribution::read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LeftCensoredDistribution, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject LeftCensoredDistribution_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__LeftCensoredDistribution, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_multinomialCovariance1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistribution1D *arg1 = 0 ;
	double arg2 ;
	unsigned int arg3 ;
	double arg4 ;
	double arg5 ;
	unsigned int arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	npstat::Matrix< double,16 > result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:multinomialCovariance1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "multinomialCovariance1D" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multinomialCovariance1D" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "multinomialCovariance1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "multinomialCovariance1D" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "multinomialCovariance1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "multinomialCovariance1D" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "multinomialCovariance1D" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	{
	try {
	result = npstat::multinomialCovariance1D((npstat::AbsDistribution1D const &)*arg1,arg2,arg3,arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::Matrix< double,16 >(static_cast< const npstat::Matrix< double,16 >& >(result))), SWIGTYPE_p_npstat__MatrixT_double_16_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_multinomialCovariance1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistribution1D *arg1 = 0 ;
	double arg2 ;
	unsigned int arg3 ;
	double arg4 ;
	double arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	npstat::Matrix< double,16 > result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:multinomialCovariance1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "multinomialCovariance1D" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "multinomialCovariance1D" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "multinomialCovariance1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "multinomialCovariance1D" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "multinomialCovariance1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "multinomialCovariance1D" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	{
	try {
	result = npstat::multinomialCovariance1D((npstat::AbsDistribution1D const &)*arg1,arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::Matrix< double,16 >(static_cast< const npstat::Matrix< double,16 >& >(result))), SWIGTYPE_p_npstat__MatrixT_double_16_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_multinomialCovariance1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[7] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 6) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_multinomialCovariance1D__SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_multinomialCovariance1D__SWIG_0(self, args);
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'multinomialCovariance1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::multinomialCovariance1D(npstat::AbsDistribution1D const &,double,unsigned int,double,double,unsigned int)\n"
	" npstat::multinomialCovariance1D(npstat::AbsDistribution1D const &,double,unsigned int,double,double)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_new_DistributionMix1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DistributionMix1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_DistributionMix1D")) SWIG_fail;
	{
	try {
	result = (npstat::DistributionMix1D *)new npstat::DistributionMix1D();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DistributionMix1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DistributionMix1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DistributionMix1D *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::DistributionMix1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_DistributionMix1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DistributionMix1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DistributionMix1D" "', argument " "1"" of type '" "npstat::DistributionMix1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DistributionMix1D" "', argument " "1"" of type '" "npstat::DistributionMix1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::DistributionMix1D * >(argp1);
	{
	try {
	result = (npstat::DistributionMix1D )new npstat::DistributionMix1D((npstat::DistributionMix1D const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DistributionMix1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DistributionMix1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 0) {
	return _wrap_new_DistributionMix1D__SWIG_0(self, args);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DistributionMix1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DistributionMix1D__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DistributionMix1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::DistributionMix1D::DistributionMix1D()\n"
	" npstat::DistributionMix1D::DistributionMix1D(npstat::DistributionMix1D const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DistributionMix1D_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DistributionMix1D arg1 = (npstat::DistributionMix1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::DistributionMix1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DistributionMix1D_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DistributionMix1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DistributionMix1D_clone" "', argument " "1"" of type '" "npstat::DistributionMix1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DistributionMix1D * >(argp1);
	{
	try {
	result = (npstat::DistributionMix1D )((npstat::DistributionMix1D const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DistributionMix1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DistributionMix1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DistributionMix1D arg1 = (npstat::DistributionMix1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DistributionMix1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DistributionMix1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DistributionMix1D" "', argument " "1"" of type '" "npstat::DistributionMix1D *""'");
	}
	arg1 = reinterpret_cast< npstat::DistributionMix1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DistributionMix1D_add(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DistributionMix1D arg1 = (npstat::DistributionMix1D ) 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::DistributionMix1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DistributionMix1D_add",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DistributionMix1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DistributionMix1D_add" "', argument " "1"" of type '" "npstat::DistributionMix1D *""'");
	}
	arg1 = reinterpret_cast< npstat::DistributionMix1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DistributionMix1D_add" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DistributionMix1D_add" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DistributionMix1D_add" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (npstat::DistributionMix1D ) &(arg1)->add((npstat::AbsDistribution1D const &)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DistributionMix1D, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DistributionMix1D_setWeights(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DistributionMix1D arg1 = (npstat::DistributionMix1D ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DistributionMix1D_setWeights",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DistributionMix1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DistributionMix1D_setWeights" "', argument " "1"" of type '" "npstat::DistributionMix1D *""'");
	}
	arg1 = reinterpret_cast< npstat::DistributionMix1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DistributionMix1D_setWeights" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DistributionMix1D_setWeights" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	(arg1)->setWeights((double const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DistributionMix1D_nComponents(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DistributionMix1D arg1 = (npstat::DistributionMix1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:DistributionMix1D_nComponents",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DistributionMix1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DistributionMix1D_nComponents" "', argument " "1"" of type '" "npstat::DistributionMix1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DistributionMix1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::DistributionMix1D const *)arg1)->nComponents();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DistributionMix1D_getComponent(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DistributionMix1D arg1 = (npstat::DistributionMix1D ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::AbsDistribution1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DistributionMix1D_getComponent",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DistributionMix1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DistributionMix1D_getComponent" "', argument " "1"" of type '" "npstat::DistributionMix1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DistributionMix1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DistributionMix1D_getComponent" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (npstat::AbsDistribution1D ) &((npstat::DistributionMix1D const )arg1)->getComponent(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DistributionMix1D_getWeight(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DistributionMix1D arg1 = (npstat::DistributionMix1D ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DistributionMix1D_getWeight",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DistributionMix1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DistributionMix1D_getWeight" "', argument " "1"" of type '" "npstat::DistributionMix1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DistributionMix1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DistributionMix1D_getWeight" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (double)((npstat::DistributionMix1D const *)arg1)->getWeight(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DistributionMix1D_density(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DistributionMix1D arg1 = (npstat::DistributionMix1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DistributionMix1D_density",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DistributionMix1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DistributionMix1D_density" "', argument " "1"" of type '" "npstat::DistributionMix1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DistributionMix1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DistributionMix1D_density" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::DistributionMix1D const *)arg1)->density(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DistributionMix1D_cdf(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DistributionMix1D arg1 = (npstat::DistributionMix1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DistributionMix1D_cdf",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DistributionMix1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DistributionMix1D_cdf" "', argument " "1"" of type '" "npstat::DistributionMix1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DistributionMix1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DistributionMix1D_cdf" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::DistributionMix1D const *)arg1)->cdf(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DistributionMix1D_exceedance(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DistributionMix1D arg1 = (npstat::DistributionMix1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DistributionMix1D_exceedance",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DistributionMix1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DistributionMix1D_exceedance" "', argument " "1"" of type '" "npstat::DistributionMix1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DistributionMix1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DistributionMix1D_exceedance" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::DistributionMix1D const *)arg1)->exceedance(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DistributionMix1D_quantile(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DistributionMix1D arg1 = (npstat::DistributionMix1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DistributionMix1D_quantile",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DistributionMix1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DistributionMix1D_quantile" "', argument " "1"" of type '" "npstat::DistributionMix1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DistributionMix1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DistributionMix1D_quantile" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::DistributionMix1D const *)arg1)->quantile(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DistributionMix1D_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DistributionMix1D arg1 = (npstat::DistributionMix1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:DistributionMix1D_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DistributionMix1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DistributionMix1D_classId" "', argument " "1"" of type '" "npstat::DistributionMix1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DistributionMix1D * >(argp1);
	{
	try {
	result = ((npstat::DistributionMix1D const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DistributionMix1D_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DistributionMix1D arg1 = (npstat::DistributionMix1D ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DistributionMix1D_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DistributionMix1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DistributionMix1D_write" "', argument " "1"" of type '" "npstat::DistributionMix1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DistributionMix1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DistributionMix1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DistributionMix1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::DistributionMix1D const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DistributionMix1D_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":DistributionMix1D_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::DistributionMix1D::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DistributionMix1D_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":DistributionMix1D_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::DistributionMix1D::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DistributionMix1D_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::DistributionMix1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DistributionMix1D_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DistributionMix1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DistributionMix1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DistributionMix1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DistributionMix1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::DistributionMix1D )npstat::DistributionMix1D::read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DistributionMix1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DistributionMix1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__DistributionMix1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_DoubleHistoNDFunctor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleHistoNDFunctor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleHistoNDFunctor" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleHistoNDFunctor_minDim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleHistoNDFunctor_minDim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleHistoNDFunctor_minDim" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > const *)arg1)->minDim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleHistoNDFunctor___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleHistoNDFunctor___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleHistoNDFunctor___call__" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleHistoNDFunctor___call__" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleHistoNDFunctor___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleHistoNDFunctor_interpolationDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleHistoNDFunctor_interpolationDegree",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleHistoNDFunctor_interpolationDegree" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > const *)arg1)->interpolationDegree();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleHistoNDFunctor_setInterpolationDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleHistoNDFunctor_setInterpolationDegree",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleHistoNDFunctor_setInterpolationDegree" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleHistoNDFunctor_setInterpolationDegree" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	(arg1)->setInterpolationDegree(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleHistoNDFunctor_interpolator__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleHistoNDFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleHistoNDFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis >::Table *) &(arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__HistoNDT_double_npstat__DualHistoAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleHistoNDFunctor_interpolator__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleHistoNDFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleHistoNDFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis >::Table ) &((npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > const )arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__HistoNDT_double_npstat__DualHistoAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleHistoNDFunctor_interpolator(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleHistoNDFunctor_interpolator__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleHistoNDFunctor_interpolator__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleHistoNDFunctor_interpolator'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis >::interpolator()\n"
	" npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis >::interpolator() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleHistoNDFunctor_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleHistoNDFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleHistoNDFunctor_table" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleHistoNDFunctor_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleHistoNDFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleHistoNDFunctor_table" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > ) &((npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleHistoNDFunctor_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleHistoNDFunctor_table__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleHistoNDFunctor_table__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleHistoNDFunctor_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis >::table()\n"
	" npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis >::table() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleHistoNDFunctor_setConverter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > ) 0 ;
	npstat::Same< double > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleHistoNDFunctor_setConverter",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleHistoNDFunctor_setConverter" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__SameT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleHistoNDFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleHistoNDFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::Same< double > * >(argp2);
	{
	try {
	(arg1)->setConverter((npstat::Same< double > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleHistoNDFunctor_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleHistoNDFunctor_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleHistoNDFunctor_classId" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = ((npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleHistoNDFunctor_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleHistoNDFunctor_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleHistoNDFunctor_write" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleHistoNDFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleHistoNDFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleHistoNDFunctor_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":DoubleHistoNDFunctor_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleHistoNDFunctor_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":DoubleHistoNDFunctor_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleHistoNDFunctor_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleHistoNDFunctor_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleHistoNDFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleHistoNDFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleHistoNDFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleHistoNDFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis > )npstat::StorableHistoNDFunctor< double,npstat::DualHistoAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleHistoNDFunctor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__DualHistoAxis_npstat__SameT_double_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_DoubleUAHistoNDFunctor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleUAHistoNDFunctor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleUAHistoNDFunctor" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAHistoNDFunctor_minDim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleUAHistoNDFunctor_minDim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAHistoNDFunctor_minDim" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > const *)arg1)->minDim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAHistoNDFunctor___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleUAHistoNDFunctor___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAHistoNDFunctor___call__" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleUAHistoNDFunctor___call__" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleUAHistoNDFunctor___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAHistoNDFunctor_interpolationDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleUAHistoNDFunctor_interpolationDegree",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAHistoNDFunctor_interpolationDegree" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > const *)arg1)->interpolationDegree();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAHistoNDFunctor_setInterpolationDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleUAHistoNDFunctor_setInterpolationDegree",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAHistoNDFunctor_setInterpolationDegree" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleUAHistoNDFunctor_setInterpolationDegree" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	(arg1)->setInterpolationDegree(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAHistoNDFunctor_interpolator__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableHistoNDFunctor< double,npstat::HistoAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleUAHistoNDFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAHistoNDFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< double,npstat::HistoAxis >::Table *) &(arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAHistoNDFunctor_interpolator__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableHistoNDFunctor< double,npstat::HistoAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleUAHistoNDFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAHistoNDFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< double,npstat::HistoAxis >::Table ) &((npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > const )arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAHistoNDFunctor_interpolator(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleUAHistoNDFunctor_interpolator__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleUAHistoNDFunctor_interpolator__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleUAHistoNDFunctor_interpolator'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableHistoNDFunctor< double,npstat::HistoAxis >::interpolator()\n"
	" npstat::StorableHistoNDFunctor< double,npstat::HistoAxis >::interpolator() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleUAHistoNDFunctor_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleUAHistoNDFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAHistoNDFunctor_table" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAHistoNDFunctor_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleUAHistoNDFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAHistoNDFunctor_table" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > ) &((npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAHistoNDFunctor_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleUAHistoNDFunctor_table__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleUAHistoNDFunctor_table__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleUAHistoNDFunctor_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableHistoNDFunctor< double,npstat::HistoAxis >::table()\n"
	" npstat::StorableHistoNDFunctor< double,npstat::HistoAxis >::table() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleUAHistoNDFunctor_setConverter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > ) 0 ;
	npstat::Same< double > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleUAHistoNDFunctor_setConverter",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAHistoNDFunctor_setConverter" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__SameT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleUAHistoNDFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleUAHistoNDFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::Same< double > * >(argp2);
	{
	try {
	(arg1)->setConverter((npstat::Same< double > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAHistoNDFunctor_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleUAHistoNDFunctor_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAHistoNDFunctor_classId" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = ((npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAHistoNDFunctor_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleUAHistoNDFunctor_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAHistoNDFunctor_write" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleUAHistoNDFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleUAHistoNDFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAHistoNDFunctor_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":DoubleUAHistoNDFunctor_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::StorableHistoNDFunctor< double,npstat::HistoAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAHistoNDFunctor_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":DoubleUAHistoNDFunctor_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::StorableHistoNDFunctor< double,npstat::HistoAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleUAHistoNDFunctor_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleUAHistoNDFunctor_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleUAHistoNDFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleUAHistoNDFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleUAHistoNDFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleUAHistoNDFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< double,npstat::HistoAxis > )npstat::StorableHistoNDFunctor< double,npstat::HistoAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleUAHistoNDFunctor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__HistoAxis_npstat__SameT_double_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_DoubleNUHistoNDFunctor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleNUHistoNDFunctor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleNUHistoNDFunctor" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUHistoNDFunctor_minDim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNUHistoNDFunctor_minDim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUHistoNDFunctor_minDim" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > const *)arg1)->minDim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUHistoNDFunctor___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleNUHistoNDFunctor___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUHistoNDFunctor___call__" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleNUHistoNDFunctor___call__" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleNUHistoNDFunctor___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUHistoNDFunctor_interpolationDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNUHistoNDFunctor_interpolationDegree",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUHistoNDFunctor_interpolationDegree" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > const *)arg1)->interpolationDegree();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUHistoNDFunctor_setInterpolationDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNUHistoNDFunctor_setInterpolationDegree",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUHistoNDFunctor_setInterpolationDegree" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleNUHistoNDFunctor_setInterpolationDegree" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	(arg1)->setInterpolationDegree(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUHistoNDFunctor_interpolator__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNUHistoNDFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUHistoNDFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis >::Table *) &(arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__HistoNDT_double_npstat__NUHistoAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUHistoNDFunctor_interpolator__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNUHistoNDFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUHistoNDFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis >::Table ) &((npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > const )arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__HistoNDT_double_npstat__NUHistoAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUHistoNDFunctor_interpolator(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleNUHistoNDFunctor_interpolator__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleNUHistoNDFunctor_interpolator__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleNUHistoNDFunctor_interpolator'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis >::interpolator()\n"
	" npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis >::interpolator() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleNUHistoNDFunctor_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNUHistoNDFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUHistoNDFunctor_table" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUHistoNDFunctor_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNUHistoNDFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUHistoNDFunctor_table" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< double > ) &((npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUHistoNDFunctor_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleNUHistoNDFunctor_table__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_DoubleNUHistoNDFunctor_table__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'DoubleNUHistoNDFunctor_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis >::table()\n"
	" npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis >::table() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleNUHistoNDFunctor_setConverter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > ) 0 ;
	npstat::Same< double > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNUHistoNDFunctor_setConverter",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUHistoNDFunctor_setConverter" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__SameT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleNUHistoNDFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleNUHistoNDFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::Same< double > * >(argp2);
	{
	try {
	(arg1)->setConverter((npstat::Same< double > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUHistoNDFunctor_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleNUHistoNDFunctor_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUHistoNDFunctor_classId" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = ((npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUHistoNDFunctor_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNUHistoNDFunctor_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUHistoNDFunctor_write" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleNUHistoNDFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleNUHistoNDFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUHistoNDFunctor_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":DoubleNUHistoNDFunctor_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUHistoNDFunctor_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":DoubleNUHistoNDFunctor_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleNUHistoNDFunctor_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleNUHistoNDFunctor_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleNUHistoNDFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleNUHistoNDFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleNUHistoNDFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DoubleNUHistoNDFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis > )npstat::StorableHistoNDFunctor< double,npstat::NUHistoAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleNUHistoNDFunctor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__StorableHistoNDFunctorT_double_npstat__NUHistoAxis_npstat__SameT_double_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_FloatHistoNDFunctor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatHistoNDFunctor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatHistoNDFunctor" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatHistoNDFunctor_minDim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatHistoNDFunctor_minDim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatHistoNDFunctor_minDim" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > const *)arg1)->minDim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatHistoNDFunctor___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:FloatHistoNDFunctor___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatHistoNDFunctor___call__" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatHistoNDFunctor___call__" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatHistoNDFunctor___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatHistoNDFunctor_interpolationDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatHistoNDFunctor_interpolationDegree",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatHistoNDFunctor_interpolationDegree" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > const *)arg1)->interpolationDegree();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatHistoNDFunctor_setInterpolationDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatHistoNDFunctor_setInterpolationDegree",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatHistoNDFunctor_setInterpolationDegree" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatHistoNDFunctor_setInterpolationDegree" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	(arg1)->setInterpolationDegree(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatHistoNDFunctor_interpolator__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatHistoNDFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatHistoNDFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis >::Table *) &(arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__HistoNDT_float_npstat__DualHistoAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatHistoNDFunctor_interpolator__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatHistoNDFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatHistoNDFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis >::Table ) &((npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > const )arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__HistoNDT_float_npstat__DualHistoAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatHistoNDFunctor_interpolator(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatHistoNDFunctor_interpolator__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatHistoNDFunctor_interpolator__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatHistoNDFunctor_interpolator'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis >::interpolator()\n"
	" npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis >::interpolator() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatHistoNDFunctor_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatHistoNDFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatHistoNDFunctor_table" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatHistoNDFunctor_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatHistoNDFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatHistoNDFunctor_table" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > ) &((npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatHistoNDFunctor_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatHistoNDFunctor_table__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatHistoNDFunctor_table__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatHistoNDFunctor_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis >::table()\n"
	" npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis >::table() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatHistoNDFunctor_setConverter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > ) 0 ;
	npstat::Same< float > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatHistoNDFunctor_setConverter",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatHistoNDFunctor_setConverter" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__SameT_float_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatHistoNDFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< float > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatHistoNDFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< float > const &""'");
	}
	arg2 = reinterpret_cast< npstat::Same< float > * >(argp2);
	{
	try {
	(arg1)->setConverter((npstat::Same< float > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatHistoNDFunctor_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatHistoNDFunctor_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatHistoNDFunctor_classId" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = ((npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatHistoNDFunctor_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatHistoNDFunctor_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatHistoNDFunctor_write" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatHistoNDFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatHistoNDFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatHistoNDFunctor_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":FloatHistoNDFunctor_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatHistoNDFunctor_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":FloatHistoNDFunctor_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatHistoNDFunctor_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatHistoNDFunctor_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatHistoNDFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatHistoNDFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatHistoNDFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatHistoNDFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis > )npstat::StorableHistoNDFunctor< float,npstat::DualHistoAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatHistoNDFunctor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__DualHistoAxis_npstat__SameT_float_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_FloatUAHistoNDFunctor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatUAHistoNDFunctor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatUAHistoNDFunctor" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAHistoNDFunctor_minDim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatUAHistoNDFunctor_minDim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAHistoNDFunctor_minDim" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > const *)arg1)->minDim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAHistoNDFunctor___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:FloatUAHistoNDFunctor___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAHistoNDFunctor___call__" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatUAHistoNDFunctor___call__" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatUAHistoNDFunctor___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAHistoNDFunctor_interpolationDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatUAHistoNDFunctor_interpolationDegree",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAHistoNDFunctor_interpolationDegree" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > const *)arg1)->interpolationDegree();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAHistoNDFunctor_setInterpolationDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatUAHistoNDFunctor_setInterpolationDegree",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAHistoNDFunctor_setInterpolationDegree" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatUAHistoNDFunctor_setInterpolationDegree" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	(arg1)->setInterpolationDegree(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAHistoNDFunctor_interpolator__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableHistoNDFunctor< float,npstat::HistoAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatUAHistoNDFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAHistoNDFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< float,npstat::HistoAxis >::Table *) &(arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAHistoNDFunctor_interpolator__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableHistoNDFunctor< float,npstat::HistoAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatUAHistoNDFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAHistoNDFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< float,npstat::HistoAxis >::Table ) &((npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > const )arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAHistoNDFunctor_interpolator(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatUAHistoNDFunctor_interpolator__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatUAHistoNDFunctor_interpolator__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatUAHistoNDFunctor_interpolator'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableHistoNDFunctor< float,npstat::HistoAxis >::interpolator()\n"
	" npstat::StorableHistoNDFunctor< float,npstat::HistoAxis >::interpolator() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatUAHistoNDFunctor_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatUAHistoNDFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAHistoNDFunctor_table" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAHistoNDFunctor_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatUAHistoNDFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAHistoNDFunctor_table" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > ) &((npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAHistoNDFunctor_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatUAHistoNDFunctor_table__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatUAHistoNDFunctor_table__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatUAHistoNDFunctor_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableHistoNDFunctor< float,npstat::HistoAxis >::table()\n"
	" npstat::StorableHistoNDFunctor< float,npstat::HistoAxis >::table() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatUAHistoNDFunctor_setConverter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > ) 0 ;
	npstat::Same< float > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatUAHistoNDFunctor_setConverter",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAHistoNDFunctor_setConverter" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__SameT_float_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatUAHistoNDFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< float > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatUAHistoNDFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< float > const &""'");
	}
	arg2 = reinterpret_cast< npstat::Same< float > * >(argp2);
	{
	try {
	(arg1)->setConverter((npstat::Same< float > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAHistoNDFunctor_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatUAHistoNDFunctor_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAHistoNDFunctor_classId" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = ((npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAHistoNDFunctor_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatUAHistoNDFunctor_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAHistoNDFunctor_write" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatUAHistoNDFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatUAHistoNDFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAHistoNDFunctor_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":FloatUAHistoNDFunctor_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::StorableHistoNDFunctor< float,npstat::HistoAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAHistoNDFunctor_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":FloatUAHistoNDFunctor_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::StorableHistoNDFunctor< float,npstat::HistoAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatUAHistoNDFunctor_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatUAHistoNDFunctor_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatUAHistoNDFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatUAHistoNDFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatUAHistoNDFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatUAHistoNDFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< float,npstat::HistoAxis > )npstat::StorableHistoNDFunctor< float,npstat::HistoAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatUAHistoNDFunctor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__HistoAxis_npstat__SameT_float_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_FloatNUHistoNDFunctor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatNUHistoNDFunctor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatNUHistoNDFunctor" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUHistoNDFunctor_minDim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNUHistoNDFunctor_minDim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUHistoNDFunctor_minDim" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > const *)arg1)->minDim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUHistoNDFunctor___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:FloatNUHistoNDFunctor___call__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUHistoNDFunctor___call__" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatNUHistoNDFunctor___call__" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatNUHistoNDFunctor___call__" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > const )arg1)->operator ()((double const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUHistoNDFunctor_interpolationDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNUHistoNDFunctor_interpolationDegree",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUHistoNDFunctor_interpolationDegree" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > const *)arg1)->interpolationDegree();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUHistoNDFunctor_setInterpolationDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNUHistoNDFunctor_setInterpolationDegree",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUHistoNDFunctor_setInterpolationDegree" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatNUHistoNDFunctor_setInterpolationDegree" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	(arg1)->setInterpolationDegree(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUHistoNDFunctor_interpolator__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNUHistoNDFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUHistoNDFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis >::Table *) &(arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__HistoNDT_float_npstat__NUHistoAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUHistoNDFunctor_interpolator__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis >::Table *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNUHistoNDFunctor_interpolator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUHistoNDFunctor_interpolator" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis >::Table ) &((npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > const )arg1)->interpolator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__HistoNDT_float_npstat__NUHistoAxis_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUHistoNDFunctor_interpolator(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatNUHistoNDFunctor_interpolator__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatNUHistoNDFunctor_interpolator__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatNUHistoNDFunctor_interpolator'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis >::interpolator()\n"
	" npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis >::interpolator() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatNUHistoNDFunctor_table__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNUHistoNDFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUHistoNDFunctor_table" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > *) &(arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUHistoNDFunctor_table__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNUHistoNDFunctor_table",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUHistoNDFunctor_table" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (npstat::ArrayND< float > ) &((npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > const )arg1)->table();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUHistoNDFunctor_table(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatNUHistoNDFunctor_table__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_FloatNUHistoNDFunctor_table__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FloatNUHistoNDFunctor_table'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis >::table()\n"
	" npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis >::table() const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatNUHistoNDFunctor_setConverter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > ) 0 ;
	npstat::Same< float > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNUHistoNDFunctor_setConverter",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUHistoNDFunctor_setConverter" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__SameT_float_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatNUHistoNDFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< float > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatNUHistoNDFunctor_setConverter" "', argument " "2"" of type '" "npstat::Same< float > const &""'");
	}
	arg2 = reinterpret_cast< npstat::Same< float > * >(argp2);
	{
	try {
	(arg1)->setConverter((npstat::Same< float > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUHistoNDFunctor_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatNUHistoNDFunctor_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUHistoNDFunctor_classId" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = ((npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUHistoNDFunctor_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > arg1 = (npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNUHistoNDFunctor_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUHistoNDFunctor_write" "', argument " "1"" of type '" "npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatNUHistoNDFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatNUHistoNDFunctor_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUHistoNDFunctor_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":FloatNUHistoNDFunctor_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis >::SWIGTEMPLATEDISAMBIGUATOR classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUHistoNDFunctor_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":FloatNUHistoNDFunctor_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis >::SWIGTEMPLATEDISAMBIGUATOR version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatNUHistoNDFunctor_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatNUHistoNDFunctor_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatNUHistoNDFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatNUHistoNDFunctor_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatNUHistoNDFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FloatNUHistoNDFunctor_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis > )npstat::StorableHistoNDFunctor< float,npstat::NUHistoAxis >::SWIGTEMPLATEDISAMBIGUATOR read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatNUHistoNDFunctor_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__StorableHistoNDFunctorT_float_npstat__NUHistoAxis_npstat__SameT_float_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_StatAccumulatorArr__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_StatAccumulatorArr")) SWIG_fail;
	{
	try {
	result = (npstat::StatAccumulatorArr *)new npstat::StatAccumulatorArr();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StatAccumulatorArr, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_StatAccumulatorArr__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned long arg1 ;
	unsigned long val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::StatAccumulatorArr *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_StatAccumulatorArr",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StatAccumulatorArr" "', argument " "1"" of type '" "unsigned long""'");
	}
	arg1 = static_cast< unsigned long >(val1);
	{
	try {
	result = (npstat::StatAccumulatorArr *)new npstat::StatAccumulatorArr(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StatAccumulatorArr, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_StatAccumulatorArr(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 0) {
	return _wrap_new_StatAccumulatorArr__SWIG_0(self, args);
	}
	if (argc == 1) {
	int _v;
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_StatAccumulatorArr__SWIG_1(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StatAccumulatorArr'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StatAccumulatorArr::StatAccumulatorArr()\n"
	" npstat::StatAccumulatorArr::StatAccumulatorArr(unsigned long const)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_dim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:StatAccumulatorArr_dim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr_dim" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::StatAccumulatorArr const *)arg1)->dim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_count(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:StatAccumulatorArr_count",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr_count" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::StatAccumulatorArr const *)arg1)->count();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_min(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:StatAccumulatorArr_min",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr_min" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StatAccumulatorArr_min" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (double)((npstat::StatAccumulatorArr const *)arg1)->min(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_max(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:StatAccumulatorArr_max",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr_max" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StatAccumulatorArr_max" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (double)((npstat::StatAccumulatorArr const *)arg1)->max(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_mean(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:StatAccumulatorArr_mean",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr_mean" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StatAccumulatorArr_mean" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (double)((npstat::StatAccumulatorArr const *)arg1)->mean(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_stdev(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:StatAccumulatorArr_stdev",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr_stdev" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StatAccumulatorArr_stdev" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (double)((npstat::StatAccumulatorArr const *)arg1)->stdev(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_meanUncertainty(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:StatAccumulatorArr_meanUncertainty",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr_meanUncertainty" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StatAccumulatorArr_meanUncertainty" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (double)((npstat::StatAccumulatorArr const *)arg1)->meanUncertainty(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_accumulate(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	npstat::StatAccumulatorArr *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:StatAccumulatorArr_accumulate",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr_accumulate" "', argument " "1"" of type '" "npstat::StatAccumulatorArr *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StatAccumulatorArr_accumulate" "', argument " "2"" of type '" "npstat::StatAccumulatorArr const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StatAccumulatorArr_accumulate" "', argument " "2"" of type '" "npstat::StatAccumulatorArr const &""'");
	}
	arg2 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp2);
	{
	try {
	(arg1)->accumulate((npstat::StatAccumulatorArr const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr___iadd____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	npstat::StatAccumulatorArr *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StatAccumulatorArr *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:StatAccumulatorArr___iadd__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr___iadd__" "', argument " "1"" of type '" "npstat::StatAccumulatorArr *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StatAccumulatorArr___iadd__" "', argument " "2"" of type '" "npstat::StatAccumulatorArr const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StatAccumulatorArr___iadd__" "', argument " "2"" of type '" "npstat::StatAccumulatorArr const &""'");
	}
	arg2 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp2);
	{
	try {
	result = (npstat::StatAccumulatorArr ) &(arg1)->operator +=((npstat::StatAccumulatorArr const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StatAccumulatorArr, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_reset(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:StatAccumulatorArr_reset",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr_reset" "', argument " "1"" of type '" "npstat::StatAccumulatorArr *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	{
	try {
	(arg1)->reset();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr___add__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	npstat::StatAccumulatorArr *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StatAccumulatorArr result;

	if (!PyArg_ParseTuple(args,(char *)"OO:StatAccumulatorArr___add__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr___add__" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StatAccumulatorArr___add__" "', argument " "2"" of type '" "npstat::StatAccumulatorArr const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StatAccumulatorArr___add__" "', argument " "2"" of type '" "npstat::StatAccumulatorArr const &""'");
	}
	arg2 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp2);
	{
	try {
	result = ((npstat::StatAccumulatorArr const )arg1)->operator +((npstat::StatAccumulatorArr const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::StatAccumulatorArr(static_cast< const npstat::StatAccumulatorArr& >(result))), SWIGTYPE_p_npstat__StatAccumulatorArr, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr___eq__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	npstat::StatAccumulatorArr *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:StatAccumulatorArr___eq__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr___eq__" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StatAccumulatorArr___eq__" "', argument " "2"" of type '" "npstat::StatAccumulatorArr const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StatAccumulatorArr___eq__" "', argument " "2"" of type '" "npstat::StatAccumulatorArr const &""'");
	}
	arg2 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp2);
	{
	try {
	result = (bool)((npstat::StatAccumulatorArr const )arg1)->operator ==((npstat::StatAccumulatorArr const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr___ne__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	npstat::StatAccumulatorArr *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:StatAccumulatorArr___ne__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr___ne__" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StatAccumulatorArr___ne__" "', argument " "2"" of type '" "npstat::StatAccumulatorArr const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StatAccumulatorArr___ne__" "', argument " "2"" of type '" "npstat::StatAccumulatorArr const &""'");
	}
	arg2 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp2);
	{
	try {
	result = (bool)((npstat::StatAccumulatorArr const )arg1)->operator !=((npstat::StatAccumulatorArr const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:StatAccumulatorArr_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr_classId" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	{
	try {
	result = ((npstat::StatAccumulatorArr const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:StatAccumulatorArr_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr_write" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StatAccumulatorArr_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StatAccumulatorArr_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::StatAccumulatorArr const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":StatAccumulatorArr_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::StatAccumulatorArr::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":StatAccumulatorArr_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::StatAccumulatorArr::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	npstat::StatAccumulatorArr arg3 = (npstat::StatAccumulatorArr ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:StatAccumulatorArr_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr_restore" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StatAccumulatorArr_restore" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StatAccumulatorArr_restore" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StatAccumulatorArr_restore" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StatAccumulatorArr_restore" "', argument " "3"" of type '" "npstat::StatAccumulatorArr *""'");
	}
	arg3 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp3);
	{
	try {
	npstat::StatAccumulatorArr::restore((gs::ClassId const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr___mul__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StatAccumulatorArr result;

	if (!PyArg_ParseTuple(args,(char *)"OO:StatAccumulatorArr___mul__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr___mul__" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StatAccumulatorArr___mul__" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = ((npstat::StatAccumulatorArr const *)arg1)->mul2(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::StatAccumulatorArr(static_cast< const npstat::StatAccumulatorArr& >(result))), SWIGTYPE_p_npstat__StatAccumulatorArr, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr___div__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StatAccumulatorArr result;

	if (!PyArg_ParseTuple(args,(char *)"OO:StatAccumulatorArr___div__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr___div__" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StatAccumulatorArr___div__" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = ((npstat::StatAccumulatorArr const *)arg1)->div2(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::StatAccumulatorArr(static_cast< const npstat::StatAccumulatorArr& >(result))), SWIGTYPE_p_npstat__StatAccumulatorArr, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr___imul__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StatAccumulatorArr *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:StatAccumulatorArr___imul__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr___imul__" "', argument " "1"" of type '" "npstat::StatAccumulatorArr *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StatAccumulatorArr___imul__" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (npstat::StatAccumulatorArr *) &(arg1)->imul2(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr___idiv__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StatAccumulatorArr *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:StatAccumulatorArr___idiv__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr___idiv__" "', argument " "1"" of type '" "npstat::StatAccumulatorArr *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StatAccumulatorArr___idiv__" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (npstat::StatAccumulatorArr *) &(arg1)->idiv2(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_minArray(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:StatAccumulatorArr_minArray",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr_minArray" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StatAccumulatorArr_minArray" "', argument " "2"" of type '" "double *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StatAccumulatorArr_minArray" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	((npstat::StatAccumulatorArr const *)arg1)->minArray(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_maxArray(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:StatAccumulatorArr_maxArray",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr_maxArray" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StatAccumulatorArr_maxArray" "', argument " "2"" of type '" "double *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StatAccumulatorArr_maxArray" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	((npstat::StatAccumulatorArr const *)arg1)->maxArray(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_meanArray(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:StatAccumulatorArr_meanArray",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr_meanArray" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StatAccumulatorArr_meanArray" "', argument " "2"" of type '" "double *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StatAccumulatorArr_meanArray" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	((npstat::StatAccumulatorArr const *)arg1)->meanArray(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_stdevArray(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:StatAccumulatorArr_stdevArray",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr_stdevArray" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StatAccumulatorArr_stdevArray" "', argument " "2"" of type '" "double *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StatAccumulatorArr_stdevArray" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	((npstat::StatAccumulatorArr const *)arg1)->stdevArray(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr_meanUncertaintyArray(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:StatAccumulatorArr_meanUncertaintyArray",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr_meanUncertaintyArray" "', argument " "1"" of type '" "npstat::StatAccumulatorArr const *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StatAccumulatorArr_meanUncertaintyArray" "', argument " "2"" of type '" "double *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StatAccumulatorArr_meanUncertaintyArray" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	((npstat::StatAccumulatorArr const *)arg1)->meanUncertaintyArray(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr___iadd____SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	std::vector< double,std::allocator< double > > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StatAccumulatorArr *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:StatAccumulatorArr___iadd__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StatAccumulatorArr___iadd__" "', argument " "1"" of type '" "npstat::StatAccumulatorArr *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StatAccumulatorArr___iadd__" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StatAccumulatorArr___iadd__" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg2 = ptr;
	}
	{
	try {
	result = (npstat::StatAccumulatorArr ) &(arg1)->operator +=((std::vector< double,std::allocator< double > > const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StatAccumulatorArr, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StatAccumulatorArr___iadd__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StatAccumulatorArr, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__StatAccumulatorArr, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_StatAccumulatorArr___iadd____SWIG_0(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__StatAccumulatorArr, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_StatAccumulatorArr___iadd____SWIG_2(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'StatAccumulatorArr___iadd__'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::StatAccumulatorArr::operator +=(npstat::StatAccumulatorArr const &)\n"
	" npstat::StatAccumulatorArr::operator +=(std::vector< double,std::allocator< double > > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_StatAccumulatorArr(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StatAccumulatorArr arg1 = (npstat::StatAccumulatorArr ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_StatAccumulatorArr",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StatAccumulatorArr, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StatAccumulatorArr" "', argument " "1"" of type '" "npstat::StatAccumulatorArr *""'");
	}
	arg1 = reinterpret_cast< npstat::StatAccumulatorArr * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject StatAccumulatorArr_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__StatAccumulatorArr, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_convertToHistoAxis__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::UniformAxis *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::HistoAxis result;

	if (!PyArg_ParseTuple(args,(char *)"O:convertToHistoAxis",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__UniformAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "convertToHistoAxis" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "convertToHistoAxis" "', argument " "1"" of type '" "npstat::UniformAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::UniformAxis * >(argp1);
	{
	try {
	result = npstat::convertToHistoAxis((npstat::UniformAxis const &)*arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::HistoAxis(static_cast< const npstat::HistoAxis& >(result))), SWIGTYPE_p_npstat__HistoAxis, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_convertToGridAxis__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoAxis *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::UniformAxis result;

	if (!PyArg_ParseTuple(args,(char *)"O:convertToGridAxis",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "convertToGridAxis" "', argument " "1"" of type '" "npstat::HistoAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "convertToGridAxis" "', argument " "1"" of type '" "npstat::HistoAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoAxis * >(argp1);
	{
	try {
	result = npstat::convertToGridAxis((npstat::HistoAxis const &)*arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::UniformAxis(static_cast< const npstat::UniformAxis& >(result))), SWIGTYPE_p_npstat__UniformAxis, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_convertToGridAxis__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::NUHistoAxis *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::GridAxis result;

	if (!PyArg_ParseTuple(args,(char *)"O:convertToGridAxis",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__NUHistoAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "convertToGridAxis" "', argument " "1"" of type '" "npstat::NUHistoAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "convertToGridAxis" "', argument " "1"" of type '" "npstat::NUHistoAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::NUHistoAxis * >(argp1);
	{
	try {
	result = npstat::convertToGridAxis((npstat::NUHistoAxis const &)*arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::GridAxis(static_cast< const npstat::GridAxis& >(result))), SWIGTYPE_p_npstat__GridAxis, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_convertToHistoAxis__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GridAxis *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::NUHistoAxis result;

	if (!PyArg_ParseTuple(args,(char *)"OO:convertToHistoAxis",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__GridAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "convertToHistoAxis" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "convertToHistoAxis" "', argument " "1"" of type '" "npstat::GridAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::GridAxis * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "convertToHistoAxis" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = npstat::convertToHistoAxis((npstat::GridAxis const &)*arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::NUHistoAxis(static_cast< const npstat::NUHistoAxis& >(result))), SWIGTYPE_p_npstat__NUHistoAxis, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_convertToHistoAxis(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__UniformAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_convertToHistoAxis__SWIG_0(self, args);
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__GridAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_convertToHistoAxis__SWIG_1(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'convertToHistoAxis'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::convertToHistoAxis(npstat::UniformAxis const &)\n"
	" npstat::convertToHistoAxis(npstat::GridAxis const &,double)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_convertToGridAxis__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DualHistoAxis *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::DualAxis result;

	if (!PyArg_ParseTuple(args,(char *)"O:convertToGridAxis",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__DualHistoAxis, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "convertToGridAxis" "', argument " "1"" of type '" "npstat::DualHistoAxis const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "convertToGridAxis" "', argument " "1"" of type '" "npstat::DualHistoAxis const &""'");
	}
	arg1 = reinterpret_cast< npstat::DualHistoAxis * >(argp1);
	{
	try {
	result = npstat::convertToGridAxis((npstat::DualHistoAxis const &)*arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::DualAxis(static_cast< const npstat::DualAxis& >(result))), SWIGTYPE_p_npstat__DualAxis, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_convertToGridAxis(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_convertToGridAxis__SWIG_0(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__NUHistoAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_convertToGridAxis__SWIG_1(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DualHistoAxis, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_convertToGridAxis__SWIG_2(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'convertToGridAxis'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::convertToGridAxis(npstat::HistoAxis const &)\n"
	" npstat::convertToGridAxis(npstat::NUHistoAxis const &)\n"
	" npstat::convertToGridAxis(npstat::DualHistoAxis const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_new_InterpolatedDistribution1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::InterpolatedDistribution1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_InterpolatedDistribution1D",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InterpolatedDistribution1D" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	{
	try {
	result = (npstat::InterpolatedDistribution1D *)new npstat::InterpolatedDistribution1D(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__InterpolatedDistribution1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_InterpolatedDistribution1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::InterpolatedDistribution1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_InterpolatedDistribution1D")) SWIG_fail;
	{
	try {
	result = (npstat::InterpolatedDistribution1D *)new npstat::InterpolatedDistribution1D();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__InterpolatedDistribution1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_InterpolatedDistribution1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 0) {
	return _wrap_new_InterpolatedDistribution1D__SWIG_1(self, args);
	}
	if (argc == 1) {
	int _v;
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_InterpolatedDistribution1D__SWIG_0(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_InterpolatedDistribution1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::InterpolatedDistribution1D::InterpolatedDistribution1D(unsigned int)\n"
	" npstat::InterpolatedDistribution1D::InterpolatedDistribution1D()\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_InterpolatedDistribution1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::InterpolatedDistribution1D arg1 = (npstat::InterpolatedDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_InterpolatedDistribution1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__InterpolatedDistribution1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InterpolatedDistribution1D" "', argument " "1"" of type '" "npstat::InterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::InterpolatedDistribution1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_InterpolatedDistribution1D_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::InterpolatedDistribution1D arg1 = (npstat::InterpolatedDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::InterpolatedDistribution1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:InterpolatedDistribution1D_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__InterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolatedDistribution1D_clone" "', argument " "1"" of type '" "npstat::InterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::InterpolatedDistribution1D * >(argp1);
	{
	try {
	result = (npstat::InterpolatedDistribution1D )((npstat::InterpolatedDistribution1D const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__InterpolatedDistribution1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_InterpolatedDistribution1D_add(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::InterpolatedDistribution1D arg1 = (npstat::InterpolatedDistribution1D ) 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:InterpolatedDistribution1D_add",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__InterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolatedDistribution1D_add" "', argument " "1"" of type '" "npstat::InterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::InterpolatedDistribution1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterpolatedDistribution1D_add" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterpolatedDistribution1D_add" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterpolatedDistribution1D_add" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	(arg1)->add((npstat::AbsDistribution1D const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_InterpolatedDistribution1D_replace(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::InterpolatedDistribution1D arg1 = (npstat::InterpolatedDistribution1D ) 0 ;
	unsigned int arg2 ;
	npstat::AbsDistribution1D *arg3 = 0 ;
	double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:InterpolatedDistribution1D_replace",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__InterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolatedDistribution1D_replace" "', argument " "1"" of type '" "npstat::InterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::InterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterpolatedDistribution1D_replace" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InterpolatedDistribution1D_replace" "', argument " "3"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InterpolatedDistribution1D_replace" "', argument " "3"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg3 = reinterpret_cast< npstat::AbsDistribution1D * >(argp3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InterpolatedDistribution1D_replace" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	(arg1)->replace(arg2,(npstat::AbsDistribution1D const &)*arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_InterpolatedDistribution1D_setWeight(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::InterpolatedDistribution1D arg1 = (npstat::InterpolatedDistribution1D ) 0 ;
	unsigned int arg2 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:InterpolatedDistribution1D_setWeight",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__InterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolatedDistribution1D_setWeight" "', argument " "1"" of type '" "npstat::InterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::InterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterpolatedDistribution1D_setWeight" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterpolatedDistribution1D_setWeight" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	(arg1)->setWeight(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_InterpolatedDistribution1D_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::InterpolatedDistribution1D arg1 = (npstat::InterpolatedDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:InterpolatedDistribution1D_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__InterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolatedDistribution1D_clear" "', argument " "1"" of type '" "npstat::InterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::InterpolatedDistribution1D * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_InterpolatedDistribution1D_normalizeAutomatically(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::InterpolatedDistribution1D arg1 = (npstat::InterpolatedDistribution1D ) 0 ;
	bool arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:InterpolatedDistribution1D_normalizeAutomatically",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__InterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolatedDistribution1D_normalizeAutomatically" "', argument " "1"" of type '" "npstat::InterpolatedDistribution1D *""'");
	}
	arg1 = reinterpret_cast< npstat::InterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterpolatedDistribution1D_normalizeAutomatically" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	{
	try {
	(arg1)->normalizeAutomatically(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_InterpolatedDistribution1D_size(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::InterpolatedDistribution1D arg1 = (npstat::InterpolatedDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:InterpolatedDistribution1D_size",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__InterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolatedDistribution1D_size" "', argument " "1"" of type '" "npstat::InterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::InterpolatedDistribution1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::InterpolatedDistribution1D const *)arg1)->size();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_InterpolatedDistribution1D_expectedSize(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::InterpolatedDistribution1D arg1 = (npstat::InterpolatedDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:InterpolatedDistribution1D_expectedSize",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__InterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolatedDistribution1D_expectedSize" "', argument " "1"" of type '" "npstat::InterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::InterpolatedDistribution1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::InterpolatedDistribution1D const *)arg1)->expectedSize();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_InterpolatedDistribution1D_density(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::InterpolatedDistribution1D arg1 = (npstat::InterpolatedDistribution1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:InterpolatedDistribution1D_density",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__InterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolatedDistribution1D_density" "', argument " "1"" of type '" "npstat::InterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::InterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterpolatedDistribution1D_density" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::InterpolatedDistribution1D const *)arg1)->density(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_InterpolatedDistribution1D_cdf(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::InterpolatedDistribution1D arg1 = (npstat::InterpolatedDistribution1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:InterpolatedDistribution1D_cdf",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__InterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolatedDistribution1D_cdf" "', argument " "1"" of type '" "npstat::InterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::InterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterpolatedDistribution1D_cdf" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::InterpolatedDistribution1D const *)arg1)->cdf(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_InterpolatedDistribution1D_exceedance(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::InterpolatedDistribution1D arg1 = (npstat::InterpolatedDistribution1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:InterpolatedDistribution1D_exceedance",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__InterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolatedDistribution1D_exceedance" "', argument " "1"" of type '" "npstat::InterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::InterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterpolatedDistribution1D_exceedance" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::InterpolatedDistribution1D const *)arg1)->exceedance(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_InterpolatedDistribution1D_quantile(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::InterpolatedDistribution1D arg1 = (npstat::InterpolatedDistribution1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:InterpolatedDistribution1D_quantile",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__InterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolatedDistribution1D_quantile" "', argument " "1"" of type '" "npstat::InterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::InterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterpolatedDistribution1D_quantile" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::InterpolatedDistribution1D const *)arg1)->quantile(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_InterpolatedDistribution1D_densityAndCdf(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::InterpolatedDistribution1D arg1 = (npstat::InterpolatedDistribution1D ) 0 ;
	double arg2 ;
	double arg3 = (double ) 0 ;
	double arg4 = (double ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:InterpolatedDistribution1D_densityAndCdf",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__InterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolatedDistribution1D_densityAndCdf" "', argument " "1"" of type '" "npstat::InterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::InterpolatedDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InterpolatedDistribution1D_densityAndCdf" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InterpolatedDistribution1D_densityAndCdf" "', argument " "3"" of type '" "double *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InterpolatedDistribution1D_densityAndCdf" "', argument " "4"" of type '" "double *""'");
	}
	arg4 = reinterpret_cast< double * >(argp4);
	{
	try {
	((npstat::InterpolatedDistribution1D const *)arg1)->densityAndCdf(arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_InterpolatedDistribution1D_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::InterpolatedDistribution1D arg1 = (npstat::InterpolatedDistribution1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:InterpolatedDistribution1D_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__InterpolatedDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolatedDistribution1D_classId" "', argument " "1"" of type '" "npstat::InterpolatedDistribution1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::InterpolatedDistribution1D * >(argp1);
	{
	try {
	result = ((npstat::InterpolatedDistribution1D const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_InterpolatedDistribution1D_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":InterpolatedDistribution1D_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::InterpolatedDistribution1D::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_InterpolatedDistribution1D_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":InterpolatedDistribution1D_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::InterpolatedDistribution1D::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject InterpolatedDistribution1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__InterpolatedDistribution1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_Ref_IntArchivedNtuple__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::NtupleReference< npstat::ArchivedNtuple< int > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_IntArchivedNtuple",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_IntArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_IntArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_IntArchivedNtuple" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (npstat::NtupleReference< npstat::ArchivedNtuple< int > > )new npstat::NtupleReference< npstat::ArchivedNtuple< int > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_int_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_IntArchivedNtuple__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::NtupleReference< npstat::ArchivedNtuple< int > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_IntArchivedNtuple",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_IntArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_IntArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_IntArchivedNtuple" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_IntArchivedNtuple" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (npstat::NtupleReference< npstat::ArchivedNtuple< int > > )new npstat::NtupleReference< npstat::ArchivedNtuple< int > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_int_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_IntArchivedNtuple__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::NtupleReference< npstat::ArchivedNtuple< int > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_IntArchivedNtuple",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_IntArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_IntArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_IntArchivedNtuple" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_IntArchivedNtuple" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_IntArchivedNtuple" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_IntArchivedNtuple" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (npstat::NtupleReference< npstat::ArchivedNtuple< int > > )new npstat::NtupleReference< npstat::ArchivedNtuple< int > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_int_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_IntArchivedNtuple(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_IntArchivedNtuple__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_IntArchivedNtuple__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_IntArchivedNtuple__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_IntArchivedNtuple'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::NtupleReference< npstat::ArchivedNtuple< int > >::NtupleReference(gs::AbsArchive &,unsigned long long const)\n"
	" npstat::NtupleReference< npstat::ArchivedNtuple< int > >::NtupleReference(gs::AbsArchive &,char const ,char const )\n"
	" npstat::NtupleReference< npstat::ArchivedNtuple< int > >::NtupleReference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_IntArchivedNtuple(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::NtupleReference< npstat::ArchivedNtuple< int > > arg1 = (npstat::NtupleReference< npstat::ArchivedNtuple< int > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_IntArchivedNtuple",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_int_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_IntArchivedNtuple" "', argument " "1"" of type '" "npstat::NtupleReference< npstat::ArchivedNtuple< int > > *""'");
	}
	arg1 = reinterpret_cast< npstat::NtupleReference< npstat::ArchivedNtuple< int > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_IntArchivedNtuple_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::NtupleReference< npstat::ArchivedNtuple< int > > arg1 = (npstat::NtupleReference< npstat::ArchivedNtuple< int > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::ArchivedNtuple< int > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_IntArchivedNtuple_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_int_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_IntArchivedNtuple_retrieve" "', argument " "1"" of type '" "npstat::NtupleReference< npstat::ArchivedNtuple< int > > const *""'");
	}
	arg1 = reinterpret_cast< npstat::NtupleReference< npstat::ArchivedNtuple< int > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_IntArchivedNtuple_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (npstat::ArchivedNtuple< int > )npstat_NtupleReference_Sl_npstat_ArchivedNtuple_Sl_int_Sg__Sg__retrieve((npstat::NtupleReference< npstat::ArchivedNtuple< int > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArchivedNtupleT_int_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_IntArchivedNtuple_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_int_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_Ref_LLongArchivedNtuple__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::NtupleReference< npstat::ArchivedNtuple< long long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_LLongArchivedNtuple",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LLongArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LLongArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_LLongArchivedNtuple" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (npstat::NtupleReference< npstat::ArchivedNtuple< long long > > )new npstat::NtupleReference< npstat::ArchivedNtuple< long long > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_long_long_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LLongArchivedNtuple__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::NtupleReference< npstat::ArchivedNtuple< long long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_LLongArchivedNtuple",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LLongArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LLongArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_LLongArchivedNtuple" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_LLongArchivedNtuple" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (npstat::NtupleReference< npstat::ArchivedNtuple< long long > > )new npstat::NtupleReference< npstat::ArchivedNtuple< long long > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_long_long_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LLongArchivedNtuple__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::NtupleReference< npstat::ArchivedNtuple< long long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_LLongArchivedNtuple",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LLongArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LLongArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_LLongArchivedNtuple" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LLongArchivedNtuple" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_LLongArchivedNtuple" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LLongArchivedNtuple" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (npstat::NtupleReference< npstat::ArchivedNtuple< long long > > )new npstat::NtupleReference< npstat::ArchivedNtuple< long long > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_long_long_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LLongArchivedNtuple(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_LLongArchivedNtuple__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_LLongArchivedNtuple__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_LLongArchivedNtuple__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_LLongArchivedNtuple'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::NtupleReference< npstat::ArchivedNtuple< long long > >::NtupleReference(gs::AbsArchive &,unsigned long long const)\n"
	" npstat::NtupleReference< npstat::ArchivedNtuple< long long > >::NtupleReference(gs::AbsArchive &,char const ,char const )\n"
	" npstat::NtupleReference< npstat::ArchivedNtuple< long long > >::NtupleReference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_LLongArchivedNtuple(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::NtupleReference< npstat::ArchivedNtuple< long long > > arg1 = (npstat::NtupleReference< npstat::ArchivedNtuple< long long > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_LLongArchivedNtuple",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_long_long_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_LLongArchivedNtuple" "', argument " "1"" of type '" "npstat::NtupleReference< npstat::ArchivedNtuple< long long > > *""'");
	}
	arg1 = reinterpret_cast< npstat::NtupleReference< npstat::ArchivedNtuple< long long > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_LLongArchivedNtuple_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::NtupleReference< npstat::ArchivedNtuple< long long > > arg1 = (npstat::NtupleReference< npstat::ArchivedNtuple< long long > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::ArchivedNtuple< long long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_LLongArchivedNtuple_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_long_long_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LLongArchivedNtuple_retrieve" "', argument " "1"" of type '" "npstat::NtupleReference< npstat::ArchivedNtuple< long long > > const *""'");
	}
	arg1 = reinterpret_cast< npstat::NtupleReference< npstat::ArchivedNtuple< long long > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LLongArchivedNtuple_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (npstat::ArchivedNtuple< long long > )npstat_NtupleReference_Sl_npstat_ArchivedNtuple_Sl_long_SS_long_Sg__Sg__retrieve((npstat::NtupleReference< npstat::ArchivedNtuple< long long > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArchivedNtupleT_long_long_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_LLongArchivedNtuple_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_long_long_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_Ref_UCharArchivedNtuple__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_UCharArchivedNtuple",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UCharArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UCharArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_UCharArchivedNtuple" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > > )new npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_unsigned_char_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UCharArchivedNtuple__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_UCharArchivedNtuple",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UCharArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UCharArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_UCharArchivedNtuple" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_UCharArchivedNtuple" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > > )new npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_unsigned_char_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UCharArchivedNtuple__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_UCharArchivedNtuple",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UCharArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UCharArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_UCharArchivedNtuple" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UCharArchivedNtuple" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_UCharArchivedNtuple" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UCharArchivedNtuple" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > > )new npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_unsigned_char_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UCharArchivedNtuple(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_UCharArchivedNtuple__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_UCharArchivedNtuple__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_UCharArchivedNtuple__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_UCharArchivedNtuple'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > >::NtupleReference(gs::AbsArchive &,unsigned long long const)\n"
	" npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > >::NtupleReference(gs::AbsArchive &,char const ,char const )\n"
	" npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > >::NtupleReference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_UCharArchivedNtuple(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > > arg1 = (npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_UCharArchivedNtuple",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_unsigned_char_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_UCharArchivedNtuple" "', argument " "1"" of type '" "npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > > *""'");
	}
	arg1 = reinterpret_cast< npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_UCharArchivedNtuple_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > > arg1 = (npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::ArchivedNtuple< unsigned char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_UCharArchivedNtuple_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_unsigned_char_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UCharArchivedNtuple_retrieve" "', argument " "1"" of type '" "npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > > const *""'");
	}
	arg1 = reinterpret_cast< npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UCharArchivedNtuple_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (npstat::ArchivedNtuple< unsigned char > )npstat_NtupleReference_Sl_npstat_ArchivedNtuple_Sl_unsigned_SS_char_Sg__Sg__retrieve((npstat::NtupleReference< npstat::ArchivedNtuple< unsigned char > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArchivedNtupleT_unsigned_char_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_UCharArchivedNtuple_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_unsigned_char_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_Ref_FloatArchivedNtuple__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::NtupleReference< npstat::ArchivedNtuple< float > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_FloatArchivedNtuple",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_FloatArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_FloatArchivedNtuple" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (npstat::NtupleReference< npstat::ArchivedNtuple< float > > )new npstat::NtupleReference< npstat::ArchivedNtuple< float > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_FloatArchivedNtuple__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::NtupleReference< npstat::ArchivedNtuple< float > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_FloatArchivedNtuple",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_FloatArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_FloatArchivedNtuple" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_FloatArchivedNtuple" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (npstat::NtupleReference< npstat::ArchivedNtuple< float > > )new npstat::NtupleReference< npstat::ArchivedNtuple< float > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_FloatArchivedNtuple__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::NtupleReference< npstat::ArchivedNtuple< float > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_FloatArchivedNtuple",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_FloatArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_FloatArchivedNtuple" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatArchivedNtuple" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_FloatArchivedNtuple" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatArchivedNtuple" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (npstat::NtupleReference< npstat::ArchivedNtuple< float > > )new npstat::NtupleReference< npstat::ArchivedNtuple< float > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_FloatArchivedNtuple(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_FloatArchivedNtuple__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_FloatArchivedNtuple__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_FloatArchivedNtuple__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_FloatArchivedNtuple'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::NtupleReference< npstat::ArchivedNtuple< float > >::NtupleReference(gs::AbsArchive &,unsigned long long const)\n"
	" npstat::NtupleReference< npstat::ArchivedNtuple< float > >::NtupleReference(gs::AbsArchive &,char const ,char const )\n"
	" npstat::NtupleReference< npstat::ArchivedNtuple< float > >::NtupleReference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_FloatArchivedNtuple(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::NtupleReference< npstat::ArchivedNtuple< float > > arg1 = (npstat::NtupleReference< npstat::ArchivedNtuple< float > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_FloatArchivedNtuple",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_float_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_FloatArchivedNtuple" "', argument " "1"" of type '" "npstat::NtupleReference< npstat::ArchivedNtuple< float > > *""'");
	}
	arg1 = reinterpret_cast< npstat::NtupleReference< npstat::ArchivedNtuple< float > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_FloatArchivedNtuple_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::NtupleReference< npstat::ArchivedNtuple< float > > arg1 = (npstat::NtupleReference< npstat::ArchivedNtuple< float > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::ArchivedNtuple< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_FloatArchivedNtuple_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_FloatArchivedNtuple_retrieve" "', argument " "1"" of type '" "npstat::NtupleReference< npstat::ArchivedNtuple< float > > const *""'");
	}
	arg1 = reinterpret_cast< npstat::NtupleReference< npstat::ArchivedNtuple< float > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_FloatArchivedNtuple_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (npstat::ArchivedNtuple< float > )npstat_NtupleReference_Sl_npstat_ArchivedNtuple_Sl_float_Sg__Sg__retrieve((npstat::NtupleReference< npstat::ArchivedNtuple< float > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArchivedNtupleT_float_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_FloatArchivedNtuple_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_float_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_Ref_DoubleArchivedNtuple__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::NtupleReference< npstat::ArchivedNtuple< double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_DoubleArchivedNtuple",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DoubleArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_DoubleArchivedNtuple" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (npstat::NtupleReference< npstat::ArchivedNtuple< double > > )new npstat::NtupleReference< npstat::ArchivedNtuple< double > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DoubleArchivedNtuple__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::NtupleReference< npstat::ArchivedNtuple< double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_DoubleArchivedNtuple",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DoubleArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_DoubleArchivedNtuple" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_DoubleArchivedNtuple" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (npstat::NtupleReference< npstat::ArchivedNtuple< double > > )new npstat::NtupleReference< npstat::ArchivedNtuple< double > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DoubleArchivedNtuple__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::NtupleReference< npstat::ArchivedNtuple< double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_DoubleArchivedNtuple",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DoubleArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleArchivedNtuple" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_DoubleArchivedNtuple" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleArchivedNtuple" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_DoubleArchivedNtuple" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleArchivedNtuple" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (npstat::NtupleReference< npstat::ArchivedNtuple< double > > )new npstat::NtupleReference< npstat::ArchivedNtuple< double > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DoubleArchivedNtuple(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_DoubleArchivedNtuple__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_DoubleArchivedNtuple__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_DoubleArchivedNtuple__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_DoubleArchivedNtuple'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::NtupleReference< npstat::ArchivedNtuple< double > >::NtupleReference(gs::AbsArchive &,unsigned long long const)\n"
	" npstat::NtupleReference< npstat::ArchivedNtuple< double > >::NtupleReference(gs::AbsArchive &,char const ,char const )\n"
	" npstat::NtupleReference< npstat::ArchivedNtuple< double > >::NtupleReference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_DoubleArchivedNtuple(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::NtupleReference< npstat::ArchivedNtuple< double > > arg1 = (npstat::NtupleReference< npstat::ArchivedNtuple< double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_DoubleArchivedNtuple",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_double_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_DoubleArchivedNtuple" "', argument " "1"" of type '" "npstat::NtupleReference< npstat::ArchivedNtuple< double > > *""'");
	}
	arg1 = reinterpret_cast< npstat::NtupleReference< npstat::ArchivedNtuple< double > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_DoubleArchivedNtuple_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::NtupleReference< npstat::ArchivedNtuple< double > > arg1 = (npstat::NtupleReference< npstat::ArchivedNtuple< double > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::ArchivedNtuple< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_DoubleArchivedNtuple_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_DoubleArchivedNtuple_retrieve" "', argument " "1"" of type '" "npstat::NtupleReference< npstat::ArchivedNtuple< double > > const *""'");
	}
	arg1 = reinterpret_cast< npstat::NtupleReference< npstat::ArchivedNtuple< double > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_DoubleArchivedNtuple_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (npstat::ArchivedNtuple< double > )npstat_NtupleReference_Sl_npstat_ArchivedNtuple_Sl_double_Sg__Sg__retrieve((npstat::NtupleReference< npstat::ArchivedNtuple< double > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArchivedNtupleT_double_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_DoubleArchivedNtuple_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__NtupleReferenceT_npstat__ArchivedNtupleT_double_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_CompositeGauss1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::CompositeGauss1D arg1 = (npstat::CompositeGauss1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_CompositeGauss1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__CompositeGauss1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CompositeGauss1D" "', argument " "1"" of type '" "npstat::CompositeGauss1D *""'");
	}
	arg1 = reinterpret_cast< npstat::CompositeGauss1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_CompositeGauss1D_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::CompositeGauss1D arg1 = (npstat::CompositeGauss1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::CompositeGauss1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:CompositeGauss1D_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__CompositeGauss1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositeGauss1D_clone" "', argument " "1"" of type '" "npstat::CompositeGauss1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::CompositeGauss1D * >(argp1);
	{
	try {
	result = (npstat::CompositeGauss1D )((npstat::CompositeGauss1D const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__CompositeGauss1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject CompositeGauss1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__CompositeGauss1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_BetaGauss1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BetaGauss1D arg1 = (npstat::BetaGauss1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_BetaGauss1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BetaGauss1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BetaGauss1D" "', argument " "1"" of type '" "npstat::BetaGauss1D *""'");
	}
	arg1 = reinterpret_cast< npstat::BetaGauss1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BetaGauss1D_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BetaGauss1D arg1 = (npstat::BetaGauss1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::BetaGauss1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:BetaGauss1D_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BetaGauss1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BetaGauss1D_clone" "', argument " "1"" of type '" "npstat::BetaGauss1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::BetaGauss1D * >(argp1);
	{
	try {
	result = (npstat::BetaGauss1D )((npstat::BetaGauss1D const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__BetaGauss1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject BetaGauss1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__BetaGauss1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_LogQuadraticLadder(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LogQuadraticLadder arg1 = (npstat::LogQuadraticLadder ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LogQuadraticLadder",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LogQuadraticLadder, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LogQuadraticLadder" "', argument " "1"" of type '" "npstat::LogQuadraticLadder *""'");
	}
	arg1 = reinterpret_cast< npstat::LogQuadraticLadder * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LogQuadraticLadder_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LogQuadraticLadder arg1 = (npstat::LogQuadraticLadder ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::LogQuadraticLadder *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LogQuadraticLadder_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LogQuadraticLadder, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LogQuadraticLadder_clone" "', argument " "1"" of type '" "npstat::LogQuadraticLadder const *""'");
	}
	arg1 = reinterpret_cast< npstat::LogQuadraticLadder * >(argp1);
	{
	try {
	result = (npstat::LogQuadraticLadder )((npstat::LogQuadraticLadder const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LogQuadraticLadder, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject LogQuadraticLadder_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__LogQuadraticLadder, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_BinnedCompositeJohnson(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BinnedCompositeJohnson arg1 = (npstat::BinnedCompositeJohnson ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_BinnedCompositeJohnson",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BinnedCompositeJohnson, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinnedCompositeJohnson" "', argument " "1"" of type '" "npstat::BinnedCompositeJohnson *""'");
	}
	arg1 = reinterpret_cast< npstat::BinnedCompositeJohnson * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinnedCompositeJohnson_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BinnedCompositeJohnson arg1 = (npstat::BinnedCompositeJohnson ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::BinnedCompositeJohnson *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:BinnedCompositeJohnson_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BinnedCompositeJohnson, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinnedCompositeJohnson_clone" "', argument " "1"" of type '" "npstat::BinnedCompositeJohnson const *""'");
	}
	arg1 = reinterpret_cast< npstat::BinnedCompositeJohnson * >(argp1);
	{
	try {
	result = (npstat::BinnedCompositeJohnson )((npstat::BinnedCompositeJohnson const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__BinnedCompositeJohnson, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject BinnedCompositeJohnson_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__BinnedCompositeJohnson, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_JohnsonLadder(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::JohnsonLadder arg1 = (npstat::JohnsonLadder ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_JohnsonLadder",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__JohnsonLadder, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JohnsonLadder" "', argument " "1"" of type '" "npstat::JohnsonLadder *""'");
	}
	arg1 = reinterpret_cast< npstat::JohnsonLadder * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_JohnsonLadder_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::JohnsonLadder arg1 = (npstat::JohnsonLadder ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::JohnsonLadder *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:JohnsonLadder_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__JohnsonLadder, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JohnsonLadder_clone" "', argument " "1"" of type '" "npstat::JohnsonLadder const *""'");
	}
	arg1 = reinterpret_cast< npstat::JohnsonLadder * >(argp1);
	{
	try {
	result = (npstat::JohnsonLadder )((npstat::JohnsonLadder const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__JohnsonLadder, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject JohnsonLadder_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__JohnsonLadder, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_PolyFilter1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::PolyFilter1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_PolyFilter1D",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PolyFilter1D" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	{
	try {
	result = (npstat::PolyFilter1D *)new npstat::PolyFilter1D(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__PolyFilter1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_PolyFilter1D_peakPosition(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::PolyFilter1D arg1 = (npstat::PolyFilter1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:PolyFilter1D_peakPosition",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__PolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PolyFilter1D_peakPosition" "', argument " "1"" of type '" "npstat::PolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::PolyFilter1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::PolyFilter1D const *)arg1)->peakPosition();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_PolyFilter1D___eq__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::PolyFilter1D arg1 = (npstat::PolyFilter1D ) 0 ;
	npstat::PolyFilter1D *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:PolyFilter1D___eq__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__PolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PolyFilter1D___eq__" "', argument " "1"" of type '" "npstat::PolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::PolyFilter1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__PolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PolyFilter1D___eq__" "', argument " "2"" of type '" "npstat::PolyFilter1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PolyFilter1D___eq__" "', argument " "2"" of type '" "npstat::PolyFilter1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::PolyFilter1D * >(argp2);
	{
	try {
	result = (bool)((npstat::PolyFilter1D const )arg1)->operator ==((npstat::PolyFilter1D const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_PolyFilter1D___ne__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::PolyFilter1D arg1 = (npstat::PolyFilter1D ) 0 ;
	npstat::PolyFilter1D *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:PolyFilter1D___ne__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__PolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PolyFilter1D___ne__" "', argument " "1"" of type '" "npstat::PolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::PolyFilter1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__PolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PolyFilter1D___ne__" "', argument " "2"" of type '" "npstat::PolyFilter1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PolyFilter1D___ne__" "', argument " "2"" of type '" "npstat::PolyFilter1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::PolyFilter1D * >(argp2);
	{
	try {
	result = (bool)((npstat::PolyFilter1D const )arg1)->operator !=((npstat::PolyFilter1D const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_PolyFilter1D_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::PolyFilter1D arg1 = (npstat::PolyFilter1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:PolyFilter1D_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__PolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PolyFilter1D_classId" "', argument " "1"" of type '" "npstat::PolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::PolyFilter1D * >(argp1);
	{
	try {
	result = ((npstat::PolyFilter1D const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_PolyFilter1D_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::PolyFilter1D arg1 = (npstat::PolyFilter1D ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:PolyFilter1D_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__PolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PolyFilter1D_write" "', argument " "1"" of type '" "npstat::PolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::PolyFilter1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PolyFilter1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PolyFilter1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::PolyFilter1D const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_PolyFilter1D_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":PolyFilter1D_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::PolyFilter1D::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_PolyFilter1D_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":PolyFilter1D_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::PolyFilter1D::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_PolyFilter1D_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::PolyFilter1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:PolyFilter1D_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PolyFilter1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PolyFilter1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PolyFilter1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PolyFilter1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::PolyFilter1D )npstat::PolyFilter1D::read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__PolyFilter1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_PolyFilter1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::PolyFilter1D arg1 = (npstat::PolyFilter1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_PolyFilter1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__PolyFilter1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PolyFilter1D" "', argument " "1"" of type '" "npstat::PolyFilter1D *""'");
	}
	arg1 = reinterpret_cast< npstat::PolyFilter1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject PolyFilter1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__PolyFilter1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_AbsFilter1DBuilder(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsFilter1DBuilder arg1 = (npstat::AbsFilter1DBuilder ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_AbsFilter1DBuilder",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsFilter1DBuilder, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AbsFilter1DBuilder" "', argument " "1"" of type '" "npstat::AbsFilter1DBuilder *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsFilter1DBuilder * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsFilter1DBuilder_centralWeightLength(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsFilter1DBuilder arg1 = (npstat::AbsFilter1DBuilder ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsFilter1DBuilder_centralWeightLength",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsFilter1DBuilder, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsFilter1DBuilder_centralWeightLength" "', argument " "1"" of type '" "npstat::AbsFilter1DBuilder const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsFilter1DBuilder * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::AbsFilter1DBuilder const *)arg1)->centralWeightLength();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsFilter1DBuilder_keepAllFilters(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsFilter1DBuilder arg1 = (npstat::AbsFilter1DBuilder ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsFilter1DBuilder_keepAllFilters",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsFilter1DBuilder, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsFilter1DBuilder_keepAllFilters" "', argument " "1"" of type '" "npstat::AbsFilter1DBuilder const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsFilter1DBuilder * >(argp1);
	{
	try {
	result = (bool)((npstat::AbsFilter1DBuilder const *)arg1)->keepAllFilters();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsFilter1DBuilder_makeFilter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsFilter1DBuilder arg1 = (npstat::AbsFilter1DBuilder ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	npstat::PolyFilter1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:AbsFilter1DBuilder_makeFilter",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsFilter1DBuilder, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsFilter1DBuilder_makeFilter" "', argument " "1"" of type '" "npstat::AbsFilter1DBuilder const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsFilter1DBuilder * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbsFilter1DBuilder_makeFilter" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbsFilter1DBuilder_makeFilter" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbsFilter1DBuilder_makeFilter" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "AbsFilter1DBuilder_makeFilter" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	result = (npstat::PolyFilter1D )((npstat::AbsFilter1DBuilder const )arg1)->makeFilter((double const *)arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__PolyFilter1D, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsFilter1DBuilder_lastBandwidthFactor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsFilter1DBuilder arg1 = (npstat::AbsFilter1DBuilder ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsFilter1DBuilder_lastBandwidthFactor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsFilter1DBuilder, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsFilter1DBuilder_lastBandwidthFactor" "', argument " "1"" of type '" "npstat::AbsFilter1DBuilder const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsFilter1DBuilder * >(argp1);
	{
	try {
	result = (double)((npstat::AbsFilter1DBuilder const *)arg1)->lastBandwidthFactor();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject AbsFilter1DBuilder_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsFilter1DBuilder, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_OrthoPolyFilter1DBuilder(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPolyFilter1DBuilder arg1 = (npstat::OrthoPolyFilter1DBuilder ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_OrthoPolyFilter1DBuilder",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPolyFilter1DBuilder, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrthoPolyFilter1DBuilder" "', argument " "1"" of type '" "npstat::OrthoPolyFilter1DBuilder *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPolyFilter1DBuilder * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPolyFilter1DBuilder_makeFilter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPolyFilter1DBuilder arg1 = (npstat::OrthoPolyFilter1DBuilder ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	npstat::PolyFilter1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:OrthoPolyFilter1DBuilder_makeFilter",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPolyFilter1DBuilder, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPolyFilter1DBuilder_makeFilter" "', argument " "1"" of type '" "npstat::OrthoPolyFilter1DBuilder const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPolyFilter1DBuilder * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OrthoPolyFilter1DBuilder_makeFilter" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OrthoPolyFilter1DBuilder_makeFilter" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OrthoPolyFilter1DBuilder_makeFilter" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "OrthoPolyFilter1DBuilder_makeFilter" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	result = (npstat::PolyFilter1D )((npstat::OrthoPolyFilter1DBuilder const )arg1)->makeFilter((double const *)arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__PolyFilter1D, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPolyFilter1DBuilder_makeOrthoPoly(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPolyFilter1DBuilder arg1 = (npstat::OrthoPolyFilter1DBuilder ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	unsigned int arg5 = (unsigned int ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	npstat::OrthoPoly1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:OrthoPolyFilter1DBuilder_makeOrthoPoly",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPolyFilter1DBuilder, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPolyFilter1DBuilder_makeOrthoPoly" "', argument " "1"" of type '" "npstat::OrthoPolyFilter1DBuilder const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPolyFilter1DBuilder * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthoPolyFilter1DBuilder_makeOrthoPoly" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OrthoPolyFilter1DBuilder_makeOrthoPoly" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OrthoPolyFilter1DBuilder_makeOrthoPoly" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OrthoPolyFilter1DBuilder_makeOrthoPoly" "', argument " "5"" of type '" "unsigned int *""'");
	}
	arg5 = reinterpret_cast< unsigned int * >(argp5);
	{
	try {
	result = (npstat::OrthoPoly1D )((npstat::OrthoPolyFilter1DBuilder const )arg1)->makeOrthoPoly(arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject OrthoPolyFilter1DBuilder_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__OrthoPolyFilter1DBuilder, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_AbsBoundaryFilter1DBuilder(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBoundaryFilter1DBuilder arg1 = (npstat::AbsBoundaryFilter1DBuilder ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_AbsBoundaryFilter1DBuilder",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBoundaryFilter1DBuilder, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AbsBoundaryFilter1DBuilder" "', argument " "1"" of type '" "npstat::AbsBoundaryFilter1DBuilder *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBoundaryFilter1DBuilder * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsBoundaryFilter1DBuilder_centralWeightLength(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBoundaryFilter1DBuilder arg1 = (npstat::AbsBoundaryFilter1DBuilder ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsBoundaryFilter1DBuilder_centralWeightLength",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBoundaryFilter1DBuilder, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsBoundaryFilter1DBuilder_centralWeightLength" "', argument " "1"" of type '" "npstat::AbsBoundaryFilter1DBuilder const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBoundaryFilter1DBuilder * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::AbsBoundaryFilter1DBuilder const *)arg1)->centralWeightLength();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsBoundaryFilter1DBuilder_keepAllFilters(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBoundaryFilter1DBuilder arg1 = (npstat::AbsBoundaryFilter1DBuilder ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsBoundaryFilter1DBuilder_keepAllFilters",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBoundaryFilter1DBuilder, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsBoundaryFilter1DBuilder_keepAllFilters" "', argument " "1"" of type '" "npstat::AbsBoundaryFilter1DBuilder const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBoundaryFilter1DBuilder * >(argp1);
	{
	try {
	result = (bool)((npstat::AbsBoundaryFilter1DBuilder const *)arg1)->keepAllFilters();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsBoundaryFilter1DBuilder_makeOrthoPoly(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBoundaryFilter1DBuilder arg1 = (npstat::AbsBoundaryFilter1DBuilder ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	unsigned int arg5 = (unsigned int ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	npstat::OrthoPoly1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:AbsBoundaryFilter1DBuilder_makeOrthoPoly",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBoundaryFilter1DBuilder, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsBoundaryFilter1DBuilder_makeOrthoPoly" "', argument " "1"" of type '" "npstat::AbsBoundaryFilter1DBuilder const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBoundaryFilter1DBuilder * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbsBoundaryFilter1DBuilder_makeOrthoPoly" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbsBoundaryFilter1DBuilder_makeOrthoPoly" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbsBoundaryFilter1DBuilder_makeOrthoPoly" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "AbsBoundaryFilter1DBuilder_makeOrthoPoly" "', argument " "5"" of type '" "unsigned int *""'");
	}
	arg5 = reinterpret_cast< unsigned int * >(argp5);
	{
	try {
	result = (npstat::OrthoPoly1D )((npstat::AbsBoundaryFilter1DBuilder const )arg1)->makeOrthoPoly(arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsBoundaryFilter1DBuilder_isFolding(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBoundaryFilter1DBuilder arg1 = (npstat::AbsBoundaryFilter1DBuilder ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsBoundaryFilter1DBuilder_isFolding",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBoundaryFilter1DBuilder, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsBoundaryFilter1DBuilder_isFolding" "', argument " "1"" of type '" "npstat::AbsBoundaryFilter1DBuilder const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBoundaryFilter1DBuilder * >(argp1);
	{
	try {
	result = (bool)((npstat::AbsBoundaryFilter1DBuilder const *)arg1)->isFolding();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsBoundaryFilter1DBuilder_lastBandwidthFactor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsBoundaryFilter1DBuilder arg1 = (npstat::AbsBoundaryFilter1DBuilder ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsBoundaryFilter1DBuilder_lastBandwidthFactor",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsBoundaryFilter1DBuilder, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsBoundaryFilter1DBuilder_lastBandwidthFactor" "', argument " "1"" of type '" "npstat::AbsBoundaryFilter1DBuilder const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsBoundaryFilter1DBuilder * >(argp1);
	{
	try {
	result = (double)((npstat::AbsBoundaryFilter1DBuilder const *)arg1)->lastBandwidthFactor();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject AbsBoundaryFilter1DBuilder_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsBoundaryFilter1DBuilder, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_getBoundaryFilter1DBuilder__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoundaryHandling *arg1 = 0 ;
	npstat::AbsDistribution1D arg2 = (npstat::AbsDistribution1D ) 0 ;
	double arg3 ;
	std::vector< int,std::allocator< int > > arg4 = (std::vector< int,std::allocator< int > > ) 0 ;
	bool arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	npstat::AbsBoundaryFilter1DBuilder *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:getBoundaryFilter1DBuilder",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getBoundaryFilter1DBuilder" "', argument " "1"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getBoundaryFilter1DBuilder" "', argument " "1"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg1 = reinterpret_cast< npstat::BoundaryHandling * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getBoundaryFilter1DBuilder" "', argument " "2"" of type '" "npstat::AbsDistribution1D const *""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "getBoundaryFilter1DBuilder" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "getBoundaryFilter1DBuilder" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const *""'");
	}
	arg4 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "getBoundaryFilter1DBuilder" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	{
	try {
	result = (npstat::AbsBoundaryFilter1DBuilder )npstat::getBoundaryFilter1DBuilder_2((npstat::BoundaryHandling const &)arg1,(npstat::AbsDistribution1D const )arg2,arg3,(std::vector< int,std::allocator< int > > const )arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__AbsBoundaryFilter1DBuilder, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_getBoundaryFilter1DBuilder__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoundaryHandling *arg1 = 0 ;
	npstat::AbsDistribution1D arg2 = (npstat::AbsDistribution1D ) 0 ;
	double arg3 ;
	std::vector< int,std::allocator< int > > arg4 = (std::vector< int,std::allocator< int > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::AbsBoundaryFilter1DBuilder *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:getBoundaryFilter1DBuilder",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getBoundaryFilter1DBuilder" "', argument " "1"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getBoundaryFilter1DBuilder" "', argument " "1"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg1 = reinterpret_cast< npstat::BoundaryHandling * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getBoundaryFilter1DBuilder" "', argument " "2"" of type '" "npstat::AbsDistribution1D const *""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "getBoundaryFilter1DBuilder" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "getBoundaryFilter1DBuilder" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const *""'");
	}
	arg4 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp4);
	{
	try {
	result = (npstat::AbsBoundaryFilter1DBuilder )npstat::getBoundaryFilter1DBuilder_2((npstat::BoundaryHandling const &)arg1,(npstat::AbsDistribution1D const )arg2,arg3,(std::vector< int,std::allocator< int > > const )arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__AbsBoundaryFilter1DBuilder, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_getBoundaryFilter1DBuilder__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoundaryHandling *arg1 = 0 ;
	npstat::AbsDistribution1D arg2 = (npstat::AbsDistribution1D ) 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::AbsBoundaryFilter1DBuilder *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:getBoundaryFilter1DBuilder",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getBoundaryFilter1DBuilder" "', argument " "1"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "getBoundaryFilter1DBuilder" "', argument " "1"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg1 = reinterpret_cast< npstat::BoundaryHandling * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "getBoundaryFilter1DBuilder" "', argument " "2"" of type '" "npstat::AbsDistribution1D const *""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "getBoundaryFilter1DBuilder" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (npstat::AbsBoundaryFilter1DBuilder )npstat::getBoundaryFilter1DBuilder_2((npstat::BoundaryHandling const &)arg1,(npstat::AbsDistribution1D const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__AbsBoundaryFilter1DBuilder, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_getBoundaryFilter1DBuilder(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_getBoundaryFilter1DBuilder__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_getBoundaryFilter1DBuilder__SWIG_1(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_getBoundaryFilter1DBuilder__SWIG_0(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'getBoundaryFilter1DBuilder'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::getBoundaryFilter1DBuilder_2(npstat::BoundaryHandling const &,npstat::AbsDistribution1D const ,double,std::vector< int,std::allocator< int > > const ,bool)\n"
	" npstat::getBoundaryFilter1DBuilder_2(npstat::BoundaryHandling const &,npstat::AbsDistribution1D const ,double,std::vector< int,std::allocator< int > > const )\n"
	" npstat::getBoundaryFilter1DBuilder_2(npstat::BoundaryHandling const &,npstat::AbsDistribution1D const *,double)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_new_LocalPolyFilter1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 = (double ) 0 ;
	unsigned int arg2 ;
	npstat::AbsFilter1DBuilder *arg3 = 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::LocalPolyFilter1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_LocalPolyFilter1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalPolyFilter1D" "', argument " "1"" of type '" "double const *""'");
	}
	arg1 = reinterpret_cast< double * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_LocalPolyFilter1D" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__AbsFilter1DBuilder, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_LocalPolyFilter1D" "', argument " "3"" of type '" "npstat::AbsFilter1DBuilder const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalPolyFilter1D" "', argument " "3"" of type '" "npstat::AbsFilter1DBuilder const &""'");
	}
	arg3 = reinterpret_cast< npstat::AbsFilter1DBuilder * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_LocalPolyFilter1D" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	result = (npstat::LocalPolyFilter1D )new npstat::LocalPolyFilter1D((double const )arg1,arg2,(npstat::AbsFilter1DBuilder const &)*arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LocalPolyFilter1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LocalPolyFilter1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LocalPolyFilter1D *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::LocalPolyFilter1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_LocalPolyFilter1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LocalPolyFilter1D" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LocalPolyFilter1D" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp1);
	{
	try {
	result = (npstat::LocalPolyFilter1D )new npstat::LocalPolyFilter1D((npstat::LocalPolyFilter1D const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LocalPolyFilter1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LocalPolyFilter1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__LocalPolyFilter1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_LocalPolyFilter1D__SWIG_1(self, args);
	}
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__AbsFilter1DBuilder, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_LocalPolyFilter1D__SWIG_0(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LocalPolyFilter1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::LocalPolyFilter1D::LocalPolyFilter1D(double const *,unsigned int,npstat::AbsFilter1DBuilder const &,unsigned int)\n"
	" npstat::LocalPolyFilter1D::LocalPolyFilter1D(npstat::LocalPolyFilter1D const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_LocalPolyFilter1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LocalPolyFilter1D arg1 = (npstat::LocalPolyFilter1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LocalPolyFilter1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LocalPolyFilter1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LocalPolyFilter1D" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D *""'");
	}
	arg1 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D___eq__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LocalPolyFilter1D arg1 = (npstat::LocalPolyFilter1D ) 0 ;
	npstat::LocalPolyFilter1D *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:LocalPolyFilter1D___eq__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalPolyFilter1D___eq__" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocalPolyFilter1D___eq__" "', argument " "2"" of type '" "npstat::LocalPolyFilter1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LocalPolyFilter1D___eq__" "', argument " "2"" of type '" "npstat::LocalPolyFilter1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp2);
	{
	try {
	result = (bool)((npstat::LocalPolyFilter1D const )arg1)->operator ==((npstat::LocalPolyFilter1D const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D___ne__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LocalPolyFilter1D arg1 = (npstat::LocalPolyFilter1D ) 0 ;
	npstat::LocalPolyFilter1D *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:LocalPolyFilter1D___ne__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalPolyFilter1D___ne__" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocalPolyFilter1D___ne__" "', argument " "2"" of type '" "npstat::LocalPolyFilter1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LocalPolyFilter1D___ne__" "', argument " "2"" of type '" "npstat::LocalPolyFilter1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp2);
	{
	try {
	result = (bool)((npstat::LocalPolyFilter1D const )arg1)->operator !=((npstat::LocalPolyFilter1D const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D_taper(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LocalPolyFilter1D arg1 = (npstat::LocalPolyFilter1D ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:LocalPolyFilter1D_taper",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalPolyFilter1D_taper" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LocalPolyFilter1D_taper" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (double)((npstat::LocalPolyFilter1D const *)arg1)->taper(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D_maxDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LocalPolyFilter1D arg1 = (npstat::LocalPolyFilter1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:LocalPolyFilter1D_maxDegree",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalPolyFilter1D_maxDegree" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::LocalPolyFilter1D const *)arg1)->maxDegree();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D_dataLen(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LocalPolyFilter1D arg1 = (npstat::LocalPolyFilter1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:LocalPolyFilter1D_dataLen",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalPolyFilter1D_dataLen" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::LocalPolyFilter1D const *)arg1)->dataLen();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D_getBandwidthFactors(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LocalPolyFilter1D arg1 = (npstat::LocalPolyFilter1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< double,std::allocator< double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LocalPolyFilter1D_getBandwidthFactors",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalPolyFilter1D_getBandwidthFactors" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp1);
	{
	try {
	result = (std::vector< double,std::allocator< double > > ) &((npstat::LocalPolyFilter1D const )arg1)->getBandwidthFactors();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D_selfContribution(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LocalPolyFilter1D arg1 = (npstat::LocalPolyFilter1D ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:LocalPolyFilter1D_selfContribution",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalPolyFilter1D_selfContribution" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LocalPolyFilter1D_selfContribution" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (double)((npstat::LocalPolyFilter1D const *)arg1)->selfContribution(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D_getFilter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LocalPolyFilter1D arg1 = (npstat::LocalPolyFilter1D ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::PolyFilter1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LocalPolyFilter1D_getFilter",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalPolyFilter1D_getFilter" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LocalPolyFilter1D_getFilter" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (npstat::PolyFilter1D ) &((npstat::LocalPolyFilter1D const )arg1)->getFilter(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__PolyFilter1D, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D_getFilterMatrix(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LocalPolyFilter1D arg1 = (npstat::LocalPolyFilter1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::Matrix< double > result;

	if (!PyArg_ParseTuple(args,(char *)"O:LocalPolyFilter1D_getFilterMatrix",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalPolyFilter1D_getFilterMatrix" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp1);
	{
	try {
	result = ((npstat::LocalPolyFilter1D const *)arg1)->getFilterMatrix();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::Matrix< double >(static_cast< const npstat::Matrix< double >& >(result))), SWIGTYPE_p_npstat__MatrixT_double_16_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LocalPolyFilter1D arg1 = (npstat::LocalPolyFilter1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:LocalPolyFilter1D_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalPolyFilter1D_classId" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp1);
	{
	try {
	result = ((npstat::LocalPolyFilter1D const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LocalPolyFilter1D arg1 = (npstat::LocalPolyFilter1D ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:LocalPolyFilter1D_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalPolyFilter1D_write" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocalPolyFilter1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LocalPolyFilter1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::LocalPolyFilter1D const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":LocalPolyFilter1D_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::LocalPolyFilter1D::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":LocalPolyFilter1D_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::LocalPolyFilter1D::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::LocalPolyFilter1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LocalPolyFilter1D_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalPolyFilter1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LocalPolyFilter1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LocalPolyFilter1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LocalPolyFilter1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::LocalPolyFilter1D )npstat::LocalPolyFilter1D::read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LocalPolyFilter1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D_doublyStochasticFilter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LocalPolyFilter1D arg1 = (npstat::LocalPolyFilter1D ) 0 ;
	double arg2 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::LocalPolyFilter1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LocalPolyFilter1D_doublyStochasticFilter",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalPolyFilter1D_doublyStochasticFilter" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LocalPolyFilter1D_doublyStochasticFilter" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LocalPolyFilter1D_doublyStochasticFilter" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (npstat::LocalPolyFilter1D )((npstat::LocalPolyFilter1D const )arg1)->doublyStochasticFilter_2(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D_eigenGroomedFilter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LocalPolyFilter1D arg1 = (npstat::LocalPolyFilter1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::LocalPolyFilter1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LocalPolyFilter1D_eigenGroomedFilter",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalPolyFilter1D_eigenGroomedFilter" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp1);
	{
	try {
	result = (npstat::LocalPolyFilter1D )((npstat::LocalPolyFilter1D const )arg1)->eigenGroomedFilter_2();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D_filter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LocalPolyFilter1D arg1 = (npstat::LocalPolyFilter1D ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	double arg4 = (double ) 0 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyArrayObject *array2 = NULL ;
	int is_new_object2 = 0 ;
	PyArrayObject *array4 = NULL ;
	int is_new_object4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LocalPolyFilter1D_filter",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalPolyFilter1D_filter" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp1);
	{
	npy_intp size[1] = {
	-1
	};
	array2 = obj_to_array_contiguous_allow_conversion(obj1,
	NPY_DOUBLE,
	&is_new_object2);
	if (!array2 \|\| !require_dimensions(array2, 1) \|\|
	!require_size(array2, size, 1)) SWIG_fail;
	arg2 = (double*) array_data(array2);
	arg3 = (int) array_size(array2,0);
	}
	{
	npy_intp size[1] = {
	-1
	};
	array4 = obj_to_array_contiguous_allow_conversion(obj2,
	NPY_DOUBLE,
	&is_new_object4);
	if (!array4 \|\| !require_dimensions(array4, 1) \|\|
	!require_size(array4, size, 1)) SWIG_fail;
	arg4 = (double*) array_data(array4);
	arg5 = (int) array_size(array4,0);
	}
	{
	try {
	((npstat::LocalPolyFilter1D const )arg1)->filter_2((double const )arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	{
	if (is_new_object4 && array4)
	{
	Py_DECREF(array4);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	{
	if (is_new_object4 && array4)
	{
	Py_DECREF(array4);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LocalPolyFilter1D_convolve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LocalPolyFilter1D arg1 = (npstat::LocalPolyFilter1D ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	double arg4 = (double ) 0 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyArrayObject *array2 = NULL ;
	int is_new_object2 = 0 ;
	PyArrayObject *array4 = NULL ;
	int is_new_object4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LocalPolyFilter1D_convolve",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LocalPolyFilter1D_convolve" "', argument " "1"" of type '" "npstat::LocalPolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LocalPolyFilter1D * >(argp1);
	{
	npy_intp size[1] = {
	-1
	};
	array2 = obj_to_array_contiguous_allow_conversion(obj1,
	NPY_DOUBLE,
	&is_new_object2);
	if (!array2 \|\| !require_dimensions(array2, 1) \|\|
	!require_size(array2, size, 1)) SWIG_fail;
	arg2 = (double*) array_data(array2);
	arg3 = (int) array_size(array2,0);
	}
	{
	npy_intp size[1] = {
	-1
	};
	array4 = obj_to_array_contiguous_allow_conversion(obj2,
	NPY_DOUBLE,
	&is_new_object4);
	if (!array4 \|\| !require_dimensions(array4, 1) \|\|
	!require_size(array4, size, 1)) SWIG_fail;
	arg4 = (double*) array_data(array4);
	arg5 = (int) array_size(array4,0);
	}
	{
	try {
	((npstat::LocalPolyFilter1D const )arg1)->convolve_2((double const )arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	{
	if (is_new_object4 && array4)
	{
	Py_DECREF(array4);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object2 && array2)
	{
	Py_DECREF(array2);
	}
	}
	{
	if (is_new_object4 && array4)
	{
	Py_DECREF(array4);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject LocalPolyFilter1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__LocalPolyFilter1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DummyLocalPolyFilter1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::DummyLocalPolyFilter1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_DummyLocalPolyFilter1D",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DummyLocalPolyFilter1D" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	{
	try {
	result = (npstat::DummyLocalPolyFilter1D *)new npstat::DummyLocalPolyFilter1D(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DummyLocalPolyFilter1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DummyLocalPolyFilter1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DummyLocalPolyFilter1D arg1 = (npstat::DummyLocalPolyFilter1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DummyLocalPolyFilter1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DummyLocalPolyFilter1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DummyLocalPolyFilter1D" "', argument " "1"" of type '" "npstat::DummyLocalPolyFilter1D *""'");
	}
	arg1 = reinterpret_cast< npstat::DummyLocalPolyFilter1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DummyLocalPolyFilter1D_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DummyLocalPolyFilter1D arg1 = (npstat::DummyLocalPolyFilter1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:DummyLocalPolyFilter1D_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DummyLocalPolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DummyLocalPolyFilter1D_classId" "', argument " "1"" of type '" "npstat::DummyLocalPolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DummyLocalPolyFilter1D * >(argp1);
	{
	try {
	result = ((npstat::DummyLocalPolyFilter1D const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DummyLocalPolyFilter1D_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::DummyLocalPolyFilter1D arg1 = (npstat::DummyLocalPolyFilter1D ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:DummyLocalPolyFilter1D_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__DummyLocalPolyFilter1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DummyLocalPolyFilter1D_write" "', argument " "1"" of type '" "npstat::DummyLocalPolyFilter1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::DummyLocalPolyFilter1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DummyLocalPolyFilter1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DummyLocalPolyFilter1D_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::DummyLocalPolyFilter1D const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DummyLocalPolyFilter1D_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":DummyLocalPolyFilter1D_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::DummyLocalPolyFilter1D::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DummyLocalPolyFilter1D_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":DummyLocalPolyFilter1D_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::DummyLocalPolyFilter1D::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DummyLocalPolyFilter1D_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::DummyLocalPolyFilter1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DummyLocalPolyFilter1D_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DummyLocalPolyFilter1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DummyLocalPolyFilter1D_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DummyLocalPolyFilter1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DummyLocalPolyFilter1D_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::DummyLocalPolyFilter1D )npstat::DummyLocalPolyFilter1D::read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__DummyLocalPolyFilter1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DummyLocalPolyFilter1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__DummyLocalPolyFilter1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_symbetaWeightAt0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int arg1 ;
	double arg2 ;
	int val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:symbetaWeightAt0",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "symbetaWeightAt0" "', argument " "1"" of type '" "int""'");
	}
	arg1 = static_cast< int >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbetaWeightAt0" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)npstat::symbetaWeightAt0(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_symbetaLOrPEFilter1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int arg1 ;
	double arg2 ;
	double arg3 ;
	unsigned int arg4 ;
	double arg5 ;
	double arg6 ;
	npstat::BoundaryHandling *arg7 = 0 ;
	std::vector< int,std::allocator< int > > arg8 = (std::vector< int,std::allocator< int > > ) 0 ;
	bool arg9 ;
	int val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	void *argp8 = 0 ;
	int res8 = 0 ;
	bool val9 ;
	int ecode9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	npstat::LocalPolyFilter1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:symbetaLOrPEFilter1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	ecode1 = SWIG_AsVal_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "symbetaLOrPEFilter1D" "', argument " "1"" of type '" "int""'");
	}
	arg1 = static_cast< int >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbetaLOrPEFilter1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "symbetaLOrPEFilter1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "symbetaLOrPEFilter1D" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "symbetaLOrPEFilter1D" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "symbetaLOrPEFilter1D" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "symbetaLOrPEFilter1D" "', argument " "7"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "symbetaLOrPEFilter1D" "', argument " "7"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg7 = reinterpret_cast< npstat::BoundaryHandling * >(argp7);
	res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res8)) {
	SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "symbetaLOrPEFilter1D" "', argument " "8"" of type '" "std::vector< int,std::allocator< int > > const *""'");
	}
	arg8 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp8);
	ecode9 = SWIG_AsVal_bool(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "symbetaLOrPEFilter1D" "', argument " "9"" of type '" "bool""'");
	}
	arg9 = static_cast< bool >(val9);
	{
	try {
	result = (npstat::LocalPolyFilter1D )npstat::symbetaLOrPEFilter1D_2(arg1,arg2,arg3,arg4,arg5,arg6,(npstat::BoundaryHandling const &)arg7,(std::vector< int,std::allocator< int > > const *)arg8,arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LocalPolyFilter1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_symbetaLOrPEFilter1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int arg1 ;
	double arg2 ;
	double arg3 ;
	unsigned int arg4 ;
	double arg5 ;
	double arg6 ;
	npstat::BoundaryHandling *arg7 = 0 ;
	std::vector< int,std::allocator< int > > arg8 = (std::vector< int,std::allocator< int > > ) 0 ;
	int val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	void *argp8 = 0 ;
	int res8 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	npstat::LocalPolyFilter1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:symbetaLOrPEFilter1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
	ecode1 = SWIG_AsVal_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "symbetaLOrPEFilter1D" "', argument " "1"" of type '" "int""'");
	}
	arg1 = static_cast< int >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbetaLOrPEFilter1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "symbetaLOrPEFilter1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "symbetaLOrPEFilter1D" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "symbetaLOrPEFilter1D" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "symbetaLOrPEFilter1D" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "symbetaLOrPEFilter1D" "', argument " "7"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "symbetaLOrPEFilter1D" "', argument " "7"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg7 = reinterpret_cast< npstat::BoundaryHandling * >(argp7);
	res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res8)) {
	SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "symbetaLOrPEFilter1D" "', argument " "8"" of type '" "std::vector< int,std::allocator< int > > const *""'");
	}
	arg8 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp8);
	{
	try {
	result = (npstat::LocalPolyFilter1D )npstat::symbetaLOrPEFilter1D_2(arg1,arg2,arg3,arg4,arg5,arg6,(npstat::BoundaryHandling const &)arg7,(std::vector< int,std::allocator< int > > const *)arg8);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LocalPolyFilter1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_symbetaLOrPEFilter1D__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int arg1 ;
	double arg2 ;
	double arg3 ;
	unsigned int arg4 ;
	double arg5 ;
	double arg6 ;
	npstat::BoundaryHandling *arg7 = 0 ;
	int val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	void *argp7 = 0 ;
	int res7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	npstat::LocalPolyFilter1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:symbetaLOrPEFilter1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	ecode1 = SWIG_AsVal_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "symbetaLOrPEFilter1D" "', argument " "1"" of type '" "int""'");
	}
	arg1 = static_cast< int >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbetaLOrPEFilter1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "symbetaLOrPEFilter1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "symbetaLOrPEFilter1D" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "symbetaLOrPEFilter1D" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "symbetaLOrPEFilter1D" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "symbetaLOrPEFilter1D" "', argument " "7"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp7) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "symbetaLOrPEFilter1D" "', argument " "7"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg7 = reinterpret_cast< npstat::BoundaryHandling * >(argp7);
	{
	try {
	result = (npstat::LocalPolyFilter1D )npstat::symbetaLOrPEFilter1D_2(arg1,arg2,arg3,arg4,arg5,arg6,(npstat::BoundaryHandling const &)arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LocalPolyFilter1D, 0 \| 0 );
	+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LocalPolyFilter1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_symbetaLOrPEFilter1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[10] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 9) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 7) {
	int _v;
	{
	int res = SWIG_AsVal_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_symbetaLOrPEFilter1D__SWIG_2(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 8) {
	int _v;
	{
	int res = SWIG_AsVal_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[7], (std::vector< int,std::allocator< int > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_symbetaLOrPEFilter1D__SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 9) {
	int _v;
	{
	int res = SWIG_AsVal_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[7], (std::vector< int,std::allocator< int > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_symbetaLOrPEFilter1D__SWIG_0(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'symbetaLOrPEFilter1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::symbetaLOrPEFilter1D_2(int,double,double,unsigned int,double,double,npstat::BoundaryHandling const &,std::vector< int,std::allocator< int > > const *,bool)\n"
	" npstat::symbetaLOrPEFilter1D_2(int,double,double,unsigned int,double,double,npstat::BoundaryHandling const &,std::vector< int,std::allocator< int > > const *)\n"
	" npstat::symbetaLOrPEFilter1D_2(int,double,double,unsigned int,double,double,npstat::BoundaryHandling const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_new_ScalableGaussND__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 = (double ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::ScalableGaussND *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ScalableGaussND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScalableGaussND" "', argument " "1"" of type '" "double const *""'");
	}
	arg1 = reinterpret_cast< double * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ScalableGaussND" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScalableGaussND" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (npstat::ScalableGaussND )new npstat::ScalableGaussND((double const )arg1,(double const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ScalableGaussND, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ScalableGaussND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ScalableGaussND arg1 = (npstat::ScalableGaussND ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ScalableGaussND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ScalableGaussND, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScalableGaussND" "', argument " "1"" of type '" "npstat::ScalableGaussND *""'");
	}
	arg1 = reinterpret_cast< npstat::ScalableGaussND * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ScalableGaussND_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ScalableGaussND arg1 = (npstat::ScalableGaussND ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ScalableGaussND *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:ScalableGaussND_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ScalableGaussND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalableGaussND_clone" "', argument " "1"" of type '" "npstat::ScalableGaussND const *""'");
	}
	arg1 = reinterpret_cast< npstat::ScalableGaussND * >(argp1);
	{
	try {
	result = (npstat::ScalableGaussND )((npstat::ScalableGaussND const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ScalableGaussND, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ScalableGaussND_mappedByQuantiles(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ScalableGaussND arg1 = (npstat::ScalableGaussND ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:ScalableGaussND_mappedByQuantiles",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ScalableGaussND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalableGaussND_mappedByQuantiles" "', argument " "1"" of type '" "npstat::ScalableGaussND const *""'");
	}
	arg1 = reinterpret_cast< npstat::ScalableGaussND * >(argp1);
	{
	try {
	result = (bool)((npstat::ScalableGaussND const *)arg1)->mappedByQuantiles();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ScalableGaussND_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ScalableGaussND arg1 = (npstat::ScalableGaussND ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:ScalableGaussND_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ScalableGaussND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalableGaussND_classId" "', argument " "1"" of type '" "npstat::ScalableGaussND const *""'");
	}
	arg1 = reinterpret_cast< npstat::ScalableGaussND * >(argp1);
	{
	try {
	result = ((npstat::ScalableGaussND const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ScalableGaussND_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ScalableGaussND arg1 = (npstat::ScalableGaussND ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:ScalableGaussND_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ScalableGaussND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalableGaussND_write" "', argument " "1"" of type '" "npstat::ScalableGaussND const *""'");
	}
	arg1 = reinterpret_cast< npstat::ScalableGaussND * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalableGaussND_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalableGaussND_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::ScalableGaussND const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ScalableGaussND_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":ScalableGaussND_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::ScalableGaussND::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ScalableGaussND_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":ScalableGaussND_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::ScalableGaussND::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ScalableGaussND_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::ScalableGaussND *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:ScalableGaussND_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalableGaussND_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalableGaussND_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalableGaussND_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalableGaussND_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::ScalableGaussND )npstat::ScalableGaussND::read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ScalableGaussND, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ScalableGaussND__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 = (double ) 0 ;
	unsigned int arg2 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	PyArrayObject *array1 = NULL ;
	int is_new_object1 = 0 ;
	PyArrayObject *array3 = NULL ;
	int is_new_object3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::ScalableGaussND *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_ScalableGaussND",&obj0,&obj1)) SWIG_fail;
	{
	npy_intp size[1] = {
	-1
	};
	array1 = obj_to_array_contiguous_allow_conversion(obj0,
	NPY_DOUBLE,
	&is_new_object1);
	if (!array1 \|\| !require_dimensions(array1, 1) \|\|
	!require_size(array1, size, 1)) SWIG_fail;
	arg1 = (double*) array_data(array1);
	arg2 = (int) array_size(array1,0);
	}
	{
	npy_intp size[1] = {
	-1
	};
	array3 = obj_to_array_contiguous_allow_conversion(obj1,
	NPY_DOUBLE,
	&is_new_object3);
	if (!array3 \|\| !require_dimensions(array3, 1) \|\|
	!require_size(array3, size, 1)) SWIG_fail;
	arg3 = (double*) array_data(array3);
	arg4 = (int) array_size(array3,0);
	}
	{
	try {
	result = (npstat::ScalableGaussND )new npstat::ScalableGaussND((double const )arg1,arg2,(double const *)arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ScalableGaussND, SWIG_POINTER_NEW \| 0 );
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	{
	if (is_new_object3 && array3)
	{
	Py_DECREF(array3);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	{
	if (is_new_object3 && array3)
	{
	Py_DECREF(array3);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ScalableGaussND(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	{
	_v = is_array(argv[0]) \|\| PySequence_Check(argv[0]);
	}
	if (_v) {
	{
	_v = is_array(argv[1]) \|\| PySequence_Check(argv[1]);
	}
	if (_v) {
	if (argc <= 2) {
	return _wrap_new_ScalableGaussND__SWIG_1(self, args);
	}
	return _wrap_new_ScalableGaussND__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ScalableGaussND__SWIG_0(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ScalableGaussND'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ScalableGaussND::ScalableGaussND(double const ,double const ,unsigned int)\n"
	" npstat::ScalableGaussND::ScalableGaussND(double const ,unsigned int,double const ,unsigned int)\n");
	return 0;
	}


	SWIGINTERN PyObject ScalableGaussND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ScalableGaussND, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_inverseGaussCdf(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:inverseGaussCdf",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "inverseGaussCdf" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	{
	try {
	result = (double)npstat::inverseGaussCdf(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_incompleteBeta(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	double arg3 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:incompleteBeta",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "incompleteBeta" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "incompleteBeta" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "incompleteBeta" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (double)npstat::incompleteBeta(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_inverseIncompleteBeta(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	double arg3 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:inverseIncompleteBeta",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "inverseIncompleteBeta" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "inverseIncompleteBeta" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "inverseIncompleteBeta" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (double)npstat::inverseIncompleteBeta(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Gamma(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:Gamma",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gamma" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	{
	try {
	result = (double)npstat::Gamma(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_incompleteGamma(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:incompleteGamma",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "incompleteGamma" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "incompleteGamma" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)npstat::incompleteGamma(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_incompleteGammaC(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:incompleteGammaC",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "incompleteGammaC" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "incompleteGammaC" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)npstat::incompleteGammaC(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_inverseIncompleteGamma(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:inverseIncompleteGamma",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "inverseIncompleteGamma" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "inverseIncompleteGamma" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)npstat::inverseIncompleteGamma(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_inverseIncompleteGammaC(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:inverseIncompleteGammaC",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "inverseIncompleteGammaC" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "inverseIncompleteGammaC" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)npstat::inverseIncompleteGammaC(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_dawsonIntegral(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	long double arg1 ;
	void *argp1 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	long double result;

	if (!PyArg_ParseTuple(args,(char *)"O:dawsonIntegral",&obj0)) SWIG_fail;
	{
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_long_double, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dawsonIntegral" "', argument " "1"" of type '" "long double""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dawsonIntegral" "', argument " "1"" of type '" "long double""'");
	} else {
	long double * temp = reinterpret_cast< long double * >(argp1);
	arg1 = *temp;
	if (SWIG_IsNewObj(res1)) delete temp;
	}
	}
	{
	try {
	result = (long double)npstat::dawsonIntegral(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new long double(static_cast< const long double& >(result))), SWIGTYPE_p_long_double, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_inverseExpsqIntegral(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	long double arg1 ;
	void *argp1 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	long double result;

	if (!PyArg_ParseTuple(args,(char *)"O:inverseExpsqIntegral",&obj0)) SWIG_fail;
	{
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_long_double, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "inverseExpsqIntegral" "', argument " "1"" of type '" "long double""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "inverseExpsqIntegral" "', argument " "1"" of type '" "long double""'");
	} else {
	long double * temp = reinterpret_cast< long double * >(argp1);
	arg1 = *temp;
	if (SWIG_IsNewObj(res1)) delete temp;
	}
	}
	{
	try {
	result = (long double)npstat::inverseExpsqIntegral(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new long double(static_cast< const long double& >(result))), SWIGTYPE_p_long_double, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_normalDensityDerivative(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	long double arg2 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	void *argp2 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	long double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:normalDensityDerivative",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "normalDensityDerivative" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	{
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_long_double, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "normalDensityDerivative" "', argument " "2"" of type '" "long double""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "normalDensityDerivative" "', argument " "2"" of type '" "long double""'");
	} else {
	long double * temp = reinterpret_cast< long double * >(argp2);
	arg2 = *temp;
	if (SWIG_IsNewObj(res2)) delete temp;
	}
	}
	{
	try {
	result = (long double)npstat::normalDensityDerivative(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new long double(static_cast< const long double& >(result))), SWIGTYPE_p_long_double, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_bivariateNormalIntegral(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	double arg3 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:bivariateNormalIntegral",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bivariateNormalIntegral" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bivariateNormalIntegral" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "bivariateNormalIntegral" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (double)npstat::bivariateNormalIntegral(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Peak2D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Peak2D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_Peak2D")) SWIG_fail;
	{
	try {
	result = (npstat::Peak2D *)new npstat::Peak2D();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__Peak2D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Peak2D_rescaleCoords(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Peak2D arg1 = (npstat::Peak2D ) 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:Peak2D_rescaleCoords",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Peak2D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Peak2D_rescaleCoords" "', argument " "1"" of type '" "npstat::Peak2D *""'");
	}
	arg1 = reinterpret_cast< npstat::Peak2D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Peak2D_rescaleCoords" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Peak2D_rescaleCoords" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Peak2D_rescaleCoords" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Peak2D_rescaleCoords" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	{
	try {
	(arg1)->rescaleCoords(arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Peak2D_x_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Peak2D arg1 = (npstat::Peak2D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Peak2D_x_set",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Peak2D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Peak2D_x_set" "', argument " "1"" of type '" "npstat::Peak2D *""'");
	}
	arg1 = reinterpret_cast< npstat::Peak2D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Peak2D_x_set" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	if (arg1) (arg1)->x = arg2;
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Peak2D_x_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Peak2D arg1 = (npstat::Peak2D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:Peak2D_x_get",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Peak2D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Peak2D_x_get" "', argument " "1"" of type '" "npstat::Peak2D *""'");
	}
	arg1 = reinterpret_cast< npstat::Peak2D * >(argp1);
	result = (double) ((arg1)->x);
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Peak2D_y_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Peak2D arg1 = (npstat::Peak2D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Peak2D_y_set",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Peak2D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Peak2D_y_set" "', argument " "1"" of type '" "npstat::Peak2D *""'");
	}
	arg1 = reinterpret_cast< npstat::Peak2D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Peak2D_y_set" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	if (arg1) (arg1)->y = arg2;
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Peak2D_y_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Peak2D arg1 = (npstat::Peak2D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:Peak2D_y_get",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Peak2D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Peak2D_y_get" "', argument " "1"" of type '" "npstat::Peak2D *""'");
	}
	arg1 = reinterpret_cast< npstat::Peak2D * >(argp1);
	result = (double) ((arg1)->y);
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Peak2D_magnitude_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Peak2D arg1 = (npstat::Peak2D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Peak2D_magnitude_set",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Peak2D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Peak2D_magnitude_set" "', argument " "1"" of type '" "npstat::Peak2D *""'");
	}
	arg1 = reinterpret_cast< npstat::Peak2D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Peak2D_magnitude_set" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	if (arg1) (arg1)->magnitude = arg2;
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Peak2D_magnitude_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Peak2D arg1 = (npstat::Peak2D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:Peak2D_magnitude_get",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Peak2D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Peak2D_magnitude_get" "', argument " "1"" of type '" "npstat::Peak2D *""'");
	}
	arg1 = reinterpret_cast< npstat::Peak2D * >(argp1);
	result = (double) ((arg1)->magnitude);
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Peak2D_hessian_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Peak2D arg1 = (npstat::Peak2D ) 0 ;
	double *arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Peak2D_hessian_set",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Peak2D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Peak2D_hessian_set" "', argument " "1"" of type '" "npstat::Peak2D *""'");
	}
	arg1 = reinterpret_cast< npstat::Peak2D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Peak2D_hessian_set" "', argument " "2"" of type '" "double [3]""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	{
	if (arg2) {
	size_t ii = 0;
	for (; ii < (size_t)3; ++ii) (double )&arg1->hessian[ii] = ((double )arg2 + ii);
	} else {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""hessian""' of type '""double [3]""'");
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Peak2D_hessian_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Peak2D arg1 = (npstat::Peak2D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:Peak2D_hessian_get",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Peak2D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Peak2D_hessian_get" "', argument " "1"" of type '" "npstat::Peak2D *""'");
	}
	arg1 = reinterpret_cast< npstat::Peak2D * >(argp1);
	result = (double )(double ) ((arg1)->hessian);
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Peak2D_valid_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Peak2D arg1 = (npstat::Peak2D ) 0 ;
	bool arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Peak2D_valid_set",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Peak2D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Peak2D_valid_set" "', argument " "1"" of type '" "npstat::Peak2D *""'");
	}
	arg1 = reinterpret_cast< npstat::Peak2D * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Peak2D_valid_set" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	if (arg1) (arg1)->valid = arg2;
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Peak2D_valid_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Peak2D arg1 = (npstat::Peak2D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:Peak2D_valid_get",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Peak2D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Peak2D_valid_get" "', argument " "1"" of type '" "npstat::Peak2D *""'");
	}
	arg1 = reinterpret_cast< npstat::Peak2D * >(argp1);
	result = (bool) ((arg1)->valid);
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Peak2D_inside_set(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Peak2D arg1 = (npstat::Peak2D ) 0 ;
	bool arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Peak2D_inside_set",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Peak2D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Peak2D_inside_set" "', argument " "1"" of type '" "npstat::Peak2D *""'");
	}
	arg1 = reinterpret_cast< npstat::Peak2D * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Peak2D_inside_set" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	if (arg1) (arg1)->inside = arg2;
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Peak2D_inside_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Peak2D arg1 = (npstat::Peak2D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:Peak2D_inside_get",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Peak2D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Peak2D_inside_get" "', argument " "1"" of type '" "npstat::Peak2D *""'");
	}
	arg1 = reinterpret_cast< npstat::Peak2D * >(argp1);
	result = (bool) ((arg1)->inside);
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Peak2D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Peak2D arg1 = (npstat::Peak2D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Peak2D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__Peak2D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Peak2D" "', argument " "1"" of type '" "npstat::Peak2D *""'");
	}
	arg1 = reinterpret_cast< npstat::Peak2D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Peak2D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__Peak2D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_findPeak3by3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double (*arg1)[3] ;
	npstat::Peak2D arg2 = (npstat::Peak2D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:findPeak3by3",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_a_3__double, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "findPeak3by3" "', argument " "1"" of type '" "double const [3][3]""'");
	}
	arg1 = reinterpret_cast< double (*)[3] >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_npstat__Peak2D, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "findPeak3by3" "', argument " "2"" of type '" "npstat::Peak2D *""'");
	}
	arg2 = reinterpret_cast< npstat::Peak2D * >(argp2);
	{
	try {
	result = (bool)npstat::findPeak3by3((double const (*)[3])arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_findPeak5by5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double (*arg1)[5] ;
	npstat::Peak2D arg2 = (npstat::Peak2D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:findPeak5by5",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_a_5__double, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "findPeak5by5" "', argument " "1"" of type '" "double const [5][5]""'");
	}
	arg1 = reinterpret_cast< double (*)[5] >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_npstat__Peak2D, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "findPeak5by5" "', argument " "2"" of type '" "npstat::Peak2D *""'");
	}
	arg2 = reinterpret_cast< npstat::Peak2D * >(argp2);
	{
	try {
	result = (bool)npstat::findPeak5by5((double const (*)[5])arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_rectangleIntegralCenterAndSize(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsMultivariateFunctor *arg1 = 0 ;
	double arg2 = (double ) 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:rectangleIntegralCenterAndSize",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsMultivariateFunctor, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectangleIntegralCenterAndSize" "', argument " "1"" of type '" "npstat::AbsMultivariateFunctor const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rectangleIntegralCenterAndSize" "', argument " "1"" of type '" "npstat::AbsMultivariateFunctor const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsMultivariateFunctor * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rectangleIntegralCenterAndSize" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rectangleIntegralCenterAndSize" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "rectangleIntegralCenterAndSize" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "rectangleIntegralCenterAndSize" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	result = (double)npstat::rectangleIntegralCenterAndSize((npstat::AbsMultivariateFunctor const &)arg1,(double const )arg2,(double const *)arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_binomialCoefficient(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int arg2 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"OO:binomialCoefficient",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "binomialCoefficient" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "binomialCoefficient" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (unsigned long)npstat::binomialCoefficient(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ldBinomialCoefficient(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int arg2 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	long double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:ldBinomialCoefficient",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ldBinomialCoefficient" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ldBinomialCoefficient" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (long double)npstat::ldBinomialCoefficient(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new long double(static_cast< const long double& >(result))), SWIGTYPE_p_long_double, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_findRootInLogSpace__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Functor1< double,double > *arg1 = 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double arg4 ;
	double arg5 = (double ) 0 ;
	double arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:findRootInLogSpace",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__Functor1T_double_double_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "findRootInLogSpace" "', argument " "1"" of type '" "npstat::Functor1< double,double > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "findRootInLogSpace" "', argument " "1"" of type '" "npstat::Functor1< double,double > const &""'");
	}
	arg1 = reinterpret_cast< npstat::Functor1< double,double > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "findRootInLogSpace" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "findRootInLogSpace" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "findRootInLogSpace" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "findRootInLogSpace" "', argument " "5"" of type '" "double *""'");
	}
	arg5 = reinterpret_cast< double * >(argp5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "findRootInLogSpace" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	try {
	result = (bool)npstat::SWIGTEMPLATEDISAMBIGUATOR findRootInLogSpace< double,double >((npstat::Functor1< double,double > const &)arg1,(double const &)arg2,(double const &)*arg3,arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_findRootInLogSpace__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Functor1< double,double > *arg1 = 0 ;
	double *arg2 = 0 ;
	double *arg3 = 0 ;
	double arg4 ;
	double arg5 = (double ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	double temp3 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:findRootInLogSpace",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__Functor1T_double_double_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "findRootInLogSpace" "', argument " "1"" of type '" "npstat::Functor1< double,double > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "findRootInLogSpace" "', argument " "1"" of type '" "npstat::Functor1< double,double > const &""'");
	}
	arg1 = reinterpret_cast< npstat::Functor1< double,double > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "findRootInLogSpace" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "findRootInLogSpace" "', argument " "3"" of type '" "double""'");
	}
	temp3 = static_cast< double >(val3);
	arg3 = &temp3;
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "findRootInLogSpace" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "findRootInLogSpace" "', argument " "5"" of type '" "double *""'");
	}
	arg5 = reinterpret_cast< double * >(argp5);
	{
	try {
	result = (bool)npstat::SWIGTEMPLATEDISAMBIGUATOR findRootInLogSpace< double,double >((npstat::Functor1< double,double > const &)arg1,(double const &)arg2,(double const &)*arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_findRootInLogSpace(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[7] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 6) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__Functor1T_double_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_findRootInLogSpace__SWIG_3(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__Functor1T_double_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_findRootInLogSpace__SWIG_2(self, args);
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'findRootInLogSpace'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::findRootInLogSpace< double,double >(npstat::Functor1< double,double > const &,double const &,double const &,double,double *,double)\n"
	" npstat::findRootInLogSpace< double,double >(npstat::Functor1< double,double > const &,double const &,double const &,double,double *)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_parseOrthoPolyMethod(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char arg1 = (char ) 0 ;
	int res1 ;
	char *buf1 = 0 ;
	int alloc1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::OrthoPolyMethod result;

	if (!PyArg_ParseTuple(args,(char *)"O:parseOrthoPolyMethod",&obj0)) SWIG_fail;
	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parseOrthoPolyMethod" "', argument " "1"" of type '" "char const *""'");
	}
	arg1 = reinterpret_cast< char * >(buf1);
	{
	try {
	result = (npstat::OrthoPolyMethod)npstat::parseOrthoPolyMethod((char const *)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_int(static_cast< int >(result));
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	return resultobj;
	fail:
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_orthoPolyMethodName(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPolyMethod arg1 ;
	int val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:orthoPolyMethodName",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "orthoPolyMethodName" "', argument " "1"" of type '" "npstat::OrthoPolyMethod""'");
	}
	arg1 = static_cast< npstat::OrthoPolyMethod >(val1);
	{
	try {
	result = (char *)npstat::orthoPolyMethodName(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_validOrthoPolyMethodNames(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::string result;

	if (!PyArg_ParseTuple(args,(char *)":validOrthoPolyMethodNames")) SWIG_fail;
	{
	try {
	result = npstat::validOrthoPolyMethodNames();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ContOrthoPoly1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	std::vector< npstat::ContOrthoPoly1D::MeasurePoint,std::allocator< npstat::ContOrthoPoly1D::MeasurePoint > > *arg2 = 0 ;
	npstat::OrthoPolyMethod arg3 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::ContOrthoPoly1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ContOrthoPoly1D",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContOrthoPoly1D" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	{
	std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > ptr = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ContOrthoPoly1D" "', argument " "2"" of type '" "std::vector< npstat::ContOrthoPoly1D::MeasurePoint,std::allocator< npstat::ContOrthoPoly1D::MeasurePoint > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContOrthoPoly1D" "', argument " "2"" of type '" "std::vector< npstat::ContOrthoPoly1D::MeasurePoint,std::allocator< npstat::ContOrthoPoly1D::MeasurePoint > > const &""'");
	}
	arg2 = ptr;
	}
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ContOrthoPoly1D" "', argument " "3"" of type '" "npstat::OrthoPolyMethod""'");
	}
	arg3 = static_cast< npstat::OrthoPolyMethod >(val3);
	{
	try {
	result = (npstat::ContOrthoPoly1D )new npstat::ContOrthoPoly1D(arg1,(std::vector< npstat::ContOrthoPoly1D::MeasurePoint,std::allocator< npstat::ContOrthoPoly1D::MeasurePoint > > const &)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ContOrthoPoly1D, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ContOrthoPoly1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	std::vector< npstat::ContOrthoPoly1D::MeasurePoint,std::allocator< npstat::ContOrthoPoly1D::MeasurePoint > > *arg2 = 0 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::ContOrthoPoly1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_ContOrthoPoly1D",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContOrthoPoly1D" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	{
	std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > ptr = (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ContOrthoPoly1D" "', argument " "2"" of type '" "std::vector< npstat::ContOrthoPoly1D::MeasurePoint,std::allocator< npstat::ContOrthoPoly1D::MeasurePoint > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ContOrthoPoly1D" "', argument " "2"" of type '" "std::vector< npstat::ContOrthoPoly1D::MeasurePoint,std::allocator< npstat::ContOrthoPoly1D::MeasurePoint > > const &""'");
	}
	arg2 = ptr;
	}
	{
	try {
	result = (npstat::ContOrthoPoly1D )new npstat::ContOrthoPoly1D(arg1,(std::vector< npstat::ContOrthoPoly1D::MeasurePoint,std::allocator< npstat::ContOrthoPoly1D::MeasurePoint > > const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ContOrthoPoly1D, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ContOrthoPoly1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[1], (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_ContOrthoPoly1D__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[1], (std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ContOrthoPoly1D__SWIG_0(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ContOrthoPoly1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ContOrthoPoly1D::ContOrthoPoly1D(unsigned int,std::vector< npstat::ContOrthoPoly1D::MeasurePoint,std::allocator< npstat::ContOrthoPoly1D::MeasurePoint > > const &,npstat::OrthoPolyMethod)\n"
	" npstat::ContOrthoPoly1D::ContOrthoPoly1D(unsigned int,std::vector< npstat::ContOrthoPoly1D::MeasurePoint,std::allocator< npstat::ContOrthoPoly1D::MeasurePoint > > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_maxDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:ContOrthoPoly1D_maxDegree",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_maxDegree" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::ContOrthoPoly1D const *)arg1)->maxDegree();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_measureLength(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:ContOrthoPoly1D_measureLength",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_measureLength" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::ContOrthoPoly1D const *)arg1)->measureLength();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_measure(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::ContOrthoPoly1D::MeasurePoint result;

	if (!PyArg_ParseTuple(args,(char *)"OO:ContOrthoPoly1D_measure",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_measure" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_measure" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = ((npstat::ContOrthoPoly1D const *)arg1)->measure(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::pair< double,double > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_coordinate(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:ContOrthoPoly1D_coordinate",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_coordinate" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_coordinate" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->coordinate(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_weight(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:ContOrthoPoly1D_weight",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_weight" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_weight" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->weight(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_sumOfWeights(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:ContOrthoPoly1D_sumOfWeights",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_sumOfWeights" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->sumOfWeights();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_sumOfWeightSquares(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:ContOrthoPoly1D_sumOfWeightSquares",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_sumOfWeightSquares" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->sumOfWeightSquares();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_areAllWeightsEqual(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:ContOrthoPoly1D_areAllWeightsEqual",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_areAllWeightsEqual" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	{
	try {
	result = (bool)((npstat::ContOrthoPoly1D const *)arg1)->areAllWeightsEqual();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_minCoordinate(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:ContOrthoPoly1D_minCoordinate",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_minCoordinate" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->minCoordinate();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_maxCoordinate(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:ContOrthoPoly1D_maxCoordinate",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_maxCoordinate" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->maxCoordinate();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_meanCoordinate(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:ContOrthoPoly1D_meanCoordinate",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_meanCoordinate" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->meanCoordinate();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_effectiveSampleSize(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:ContOrthoPoly1D_effectiveSampleSize",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_effectiveSampleSize" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->effectiveSampleSize();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_poly(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ContOrthoPoly1D_poly",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_poly" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_poly" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_poly" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->poly(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_polyPair(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	std::pair< double,double > result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:ContOrthoPoly1D_polyPair",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_polyPair" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_polyPair" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_polyPair" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ContOrthoPoly1D_polyPair" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	result = ((npstat::ContOrthoPoly1D const *)arg1)->polyPair(arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::pair< double,double > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_allPolys__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	double arg2 ;
	unsigned int arg3 ;
	double arg4 = (double ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:ContOrthoPoly1D_allPolys",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_allPolys" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_allPolys" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_allPolys" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ContOrthoPoly1D_allPolys" "', argument " "4"" of type '" "double *""'");
	}
	arg4 = reinterpret_cast< double * >(argp4);
	{
	try {
	((npstat::ContOrthoPoly1D const *)arg1)->allPolys(arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_allPolys__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	double arg2 ;
	unsigned int arg3 ;
	long double arg4 = (long double ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:ContOrthoPoly1D_allPolys",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_allPolys" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_allPolys" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_allPolys" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_long_double, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ContOrthoPoly1D_allPolys" "', argument " "4"" of type '" "long double *""'");
	}
	arg4 = reinterpret_cast< long double * >(argp4);
	{
	try {
	((npstat::ContOrthoPoly1D const *)arg1)->allPolys(arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_allPolys(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ContOrthoPoly1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ContOrthoPoly1D_allPolys__SWIG_0(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ContOrthoPoly1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_long_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ContOrthoPoly1D_allPolys__SWIG_1(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ContOrthoPoly1D_allPolys'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ContOrthoPoly1D::allPolys(double,unsigned int,double *) const\n"
	" npstat::ContOrthoPoly1D::allPolys(double,unsigned int,long double *) const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_series(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:ContOrthoPoly1D_series",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_series" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ContOrthoPoly1D_series" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_series" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ContOrthoPoly1D_series" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const )arg1)->series((double const )arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_weightCoeffs(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ContOrthoPoly1D_weightCoeffs",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_weightCoeffs" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ContOrthoPoly1D_weightCoeffs" "', argument " "2"" of type '" "double *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_weightCoeffs" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	((npstat::ContOrthoPoly1D const *)arg1)->weightCoeffs(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_empiricalKroneckerDelta(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ContOrthoPoly1D_empiricalKroneckerDelta",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_empiricalKroneckerDelta" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_empiricalKroneckerDelta" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_empiricalKroneckerDelta" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->empiricalKroneckerDelta(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_empiricalKroneckerCovariance(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:ContOrthoPoly1D_empiricalKroneckerCovariance",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_empiricalKroneckerCovariance" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_empiricalKroneckerCovariance" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_empiricalKroneckerCovariance" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ContOrthoPoly1D_empiricalKroneckerCovariance" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ContOrthoPoly1D_empiricalKroneckerCovariance" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->empiricalKroneckerCovariance(arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_recurrenceCoeffs(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::pair< double,double > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:ContOrthoPoly1D_recurrenceCoeffs",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_recurrenceCoeffs" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_recurrenceCoeffs" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = ((npstat::ContOrthoPoly1D const *)arg1)->recurrenceCoeffs(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::pair< double,double > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_jacobiMatrix(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::Matrix< double > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:ContOrthoPoly1D_jacobiMatrix",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_jacobiMatrix" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_jacobiMatrix" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = ((npstat::ContOrthoPoly1D const *)arg1)->jacobiMatrix(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::Matrix< double >(static_cast< const npstat::Matrix< double >& >(result))), SWIGTYPE_p_npstat__MatrixT_double_16_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_calculateRoots(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ContOrthoPoly1D_calculateRoots",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_calculateRoots" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ContOrthoPoly1D_calculateRoots" "', argument " "2"" of type '" "double *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_calculateRoots" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	((npstat::ContOrthoPoly1D const *)arg1)->calculateRoots(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_integratePoly(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	double arg4 ;
	double arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:ContOrthoPoly1D_integratePoly",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_integratePoly" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_integratePoly" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_integratePoly" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ContOrthoPoly1D_integratePoly" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ContOrthoPoly1D_integratePoly" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->integratePoly(arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_integrateTripleProduct(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	double arg5 ;
	double arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ContOrthoPoly1D_integrateTripleProduct",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_integrateTripleProduct" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_integrateTripleProduct" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_integrateTripleProduct" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ContOrthoPoly1D_integrateTripleProduct" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ContOrthoPoly1D_integrateTripleProduct" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ContOrthoPoly1D_integrateTripleProduct" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->integrateTripleProduct(arg2,arg3,arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_powerAverage(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ContOrthoPoly1D_powerAverage",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_powerAverage" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_powerAverage" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_powerAverage" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->powerAverage(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_jointPowerAverage(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:ContOrthoPoly1D_jointPowerAverage",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_jointPowerAverage" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_jointPowerAverage" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_jointPowerAverage" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ContOrthoPoly1D_jointPowerAverage" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ContOrthoPoly1D_jointPowerAverage" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->jointPowerAverage(arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_jointAverage__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	bool arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	bool val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:ContOrthoPoly1D_jointAverage",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_jointAverage" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ContOrthoPoly1D_jointAverage" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_jointAverage" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_bool(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ContOrthoPoly1D_jointAverage" "', argument " "4"" of type '" "bool""'");
	}
	arg4 = static_cast< bool >(val4);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const )arg1)->jointAverage((unsigned int const )arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_jointAverage__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ContOrthoPoly1D_jointAverage",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_jointAverage" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ContOrthoPoly1D_jointAverage" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_jointAverage" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const )arg1)->jointAverage((unsigned int const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_jointAverage(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ContOrthoPoly1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ContOrthoPoly1D_jointAverage__SWIG_1(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ContOrthoPoly1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ContOrthoPoly1D_jointAverage__SWIG_0(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ContOrthoPoly1D_jointAverage'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ContOrthoPoly1D::jointAverage(unsigned int const *,unsigned int,bool) const\n"
	" npstat::ContOrthoPoly1D::jointAverage(unsigned int const *,unsigned int) const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_cachedJointAverage__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:ContOrthoPoly1D_cachedJointAverage",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->cachedJointAverage(arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_cachedJointAverage__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	unsigned int arg6 ;
	unsigned int arg7 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	unsigned int val7 ;
	int ecode7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ContOrthoPoly1D_cachedJointAverage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
	if (!SWIG_IsOK(ecode7)) {
	SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "7"" of type '" "unsigned int""'");
	}
	arg7 = static_cast< unsigned int >(val7);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->cachedJointAverage(arg2,arg3,arg4,arg5,arg6,arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_cachedJointAverage__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	unsigned int arg6 ;
	unsigned int arg7 ;
	unsigned int arg8 ;
	unsigned int arg9 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	unsigned int val7 ;
	int ecode7 = 0 ;
	unsigned int val8 ;
	int ecode8 = 0 ;
	unsigned int val9 ;
	int ecode9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:ContOrthoPoly1D_cachedJointAverage",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
	if (!SWIG_IsOK(ecode7)) {
	SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "7"" of type '" "unsigned int""'");
	}
	arg7 = static_cast< unsigned int >(val7);
	ecode8 = SWIG_AsVal_unsigned_SS_int(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "8"" of type '" "unsigned int""'");
	}
	arg8 = static_cast< unsigned int >(val8);
	ecode9 = SWIG_AsVal_unsigned_SS_int(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ContOrthoPoly1D_cachedJointAverage" "', argument " "9"" of type '" "unsigned int""'");
	}
	arg9 = static_cast< unsigned int >(val9);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->cachedJointAverage(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_cachedJointAverage(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[10] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 9) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ContOrthoPoly1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ContOrthoPoly1D_cachedJointAverage__SWIG_0(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ContOrthoPoly1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ContOrthoPoly1D_cachedJointAverage__SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 9) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ContOrthoPoly1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[7], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[8], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ContOrthoPoly1D_cachedJointAverage__SWIG_2(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ContOrthoPoly1D_cachedJointAverage'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ContOrthoPoly1D::cachedJointAverage(unsigned int,unsigned int,unsigned int,unsigned int) const\n"
	" npstat::ContOrthoPoly1D::cachedJointAverage(unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int) const\n"
	" npstat::ContOrthoPoly1D::cachedJointAverage(unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int) const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_cov4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:ContOrthoPoly1D_cov4",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_cov4" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_cov4" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_cov4" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ContOrthoPoly1D_cov4" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ContOrthoPoly1D_cov4" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->cov4(arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_cov6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	unsigned int arg6 ;
	unsigned int arg7 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	unsigned int val7 ;
	int ecode7 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:ContOrthoPoly1D_cov6",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_cov6" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_cov6" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_cov6" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ContOrthoPoly1D_cov6" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ContOrthoPoly1D_cov6" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ContOrthoPoly1D_cov6" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
	if (!SWIG_IsOK(ecode7)) {
	SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ContOrthoPoly1D_cov6" "', argument " "7"" of type '" "unsigned int""'");
	}
	arg7 = static_cast< unsigned int >(val7);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->cov6(arg2,arg3,arg4,arg5,arg6,arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_cov8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	unsigned int arg6 ;
	unsigned int arg7 ;
	unsigned int arg8 ;
	unsigned int arg9 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	unsigned int val7 ;
	int ecode7 = 0 ;
	unsigned int val8 ;
	int ecode8 = 0 ;
	unsigned int val9 ;
	int ecode9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:ContOrthoPoly1D_cov8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_cov8" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_cov8" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_cov8" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ContOrthoPoly1D_cov8" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ContOrthoPoly1D_cov8" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ContOrthoPoly1D_cov8" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
	if (!SWIG_IsOK(ecode7)) {
	SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ContOrthoPoly1D_cov8" "', argument " "7"" of type '" "unsigned int""'");
	}
	arg7 = static_cast< unsigned int >(val7);
	ecode8 = SWIG_AsVal_unsigned_SS_int(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ContOrthoPoly1D_cov8" "', argument " "8"" of type '" "unsigned int""'");
	}
	arg8 = static_cast< unsigned int >(val8);
	ecode9 = SWIG_AsVal_unsigned_SS_int(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ContOrthoPoly1D_cov8" "', argument " "9"" of type '" "unsigned int""'");
	}
	arg9 = static_cast< unsigned int >(val9);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->cov8(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_covCov4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	unsigned int arg6 ;
	unsigned int arg7 ;
	unsigned int arg8 ;
	unsigned int arg9 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	unsigned int val7 ;
	int ecode7 = 0 ;
	unsigned int val8 ;
	int ecode8 = 0 ;
	unsigned int val9 ;
	int ecode9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:ContOrthoPoly1D_covCov4",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_covCov4" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_covCov4" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_covCov4" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ContOrthoPoly1D_covCov4" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ContOrthoPoly1D_covCov4" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ContOrthoPoly1D_covCov4" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
	if (!SWIG_IsOK(ecode7)) {
	SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ContOrthoPoly1D_covCov4" "', argument " "7"" of type '" "unsigned int""'");
	}
	arg7 = static_cast< unsigned int >(val7);
	ecode8 = SWIG_AsVal_unsigned_SS_int(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ContOrthoPoly1D_covCov4" "', argument " "8"" of type '" "unsigned int""'");
	}
	arg8 = static_cast< unsigned int >(val8);
	ecode9 = SWIG_AsVal_unsigned_SS_int(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ContOrthoPoly1D_covCov4" "', argument " "9"" of type '" "unsigned int""'");
	}
	arg9 = static_cast< unsigned int >(val9);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->covCov4(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_slowCov8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	unsigned int arg6 ;
	unsigned int arg7 ;
	unsigned int arg8 ;
	unsigned int arg9 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	unsigned int val7 ;
	int ecode7 = 0 ;
	unsigned int val8 ;
	int ecode8 = 0 ;
	unsigned int val9 ;
	int ecode9 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject * obj7 = 0 ;
	PyObject * obj8 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:ContOrthoPoly1D_slowCov8",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_slowCov8" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_slowCov8" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_slowCov8" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ContOrthoPoly1D_slowCov8" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ContOrthoPoly1D_slowCov8" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ContOrthoPoly1D_slowCov8" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
	if (!SWIG_IsOK(ecode7)) {
	SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ContOrthoPoly1D_slowCov8" "', argument " "7"" of type '" "unsigned int""'");
	}
	arg7 = static_cast< unsigned int >(val7);
	ecode8 = SWIG_AsVal_unsigned_SS_int(obj7, &val8);
	if (!SWIG_IsOK(ecode8)) {
	SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ContOrthoPoly1D_slowCov8" "', argument " "8"" of type '" "unsigned int""'");
	}
	arg8 = static_cast< unsigned int >(val8);
	ecode9 = SWIG_AsVal_unsigned_SS_int(obj8, &val9);
	if (!SWIG_IsOK(ecode9)) {
	SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ContOrthoPoly1D_slowCov8" "', argument " "9"" of type '" "unsigned int""'");
	}
	arg9 = static_cast< unsigned int >(val9);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->slowCov8(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_epsExpectation(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	bool arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	bool val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:ContOrthoPoly1D_epsExpectation",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_epsExpectation" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_epsExpectation" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_epsExpectation" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_bool(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ContOrthoPoly1D_epsExpectation" "', argument " "4"" of type '" "bool""'");
	}
	arg4 = static_cast< bool >(val4);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->epsExpectation(arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ContOrthoPoly1D_epsCovariance(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	bool arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	bool val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ContOrthoPoly1D_epsCovariance",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContOrthoPoly1D_epsCovariance" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ContOrthoPoly1D_epsCovariance" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ContOrthoPoly1D_epsCovariance" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ContOrthoPoly1D_epsCovariance" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ContOrthoPoly1D_epsCovariance" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	ecode6 = SWIG_AsVal_bool(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ContOrthoPoly1D_epsCovariance" "', argument " "6"" of type '" "bool""'");
	}
	arg6 = static_cast< bool >(val6);
	{
	try {
	result = (double)((npstat::ContOrthoPoly1D const *)arg1)->epsCovariance(arg2,arg3,arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ContOrthoPoly1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ContOrthoPoly1D arg1 = (npstat::ContOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ContOrthoPoly1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ContOrthoPoly1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContOrthoPoly1D" "', argument " "1"" of type '" "npstat::ContOrthoPoly1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ContOrthoPoly1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ContOrthoPoly1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ContOrthoPoly1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_GaussLegendreQuadrature(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::GaussLegendreQuadrature *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_GaussLegendreQuadrature",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussLegendreQuadrature" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	{
	try {
	result = (npstat::GaussLegendreQuadrature *)new npstat::GaussLegendreQuadrature(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__GaussLegendreQuadrature, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussLegendreQuadrature_npoints(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussLegendreQuadrature arg1 = (npstat::GaussLegendreQuadrature ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussLegendreQuadrature_npoints",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussLegendreQuadrature, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLegendreQuadrature_npoints" "', argument " "1"" of type '" "npstat::GaussLegendreQuadrature const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussLegendreQuadrature * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::GaussLegendreQuadrature const *)arg1)->npoints();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussLegendreQuadrature_isAllowed(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussLegendreQuadrature_isAllowed",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GaussLegendreQuadrature_isAllowed" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	{
	try {
	result = (bool)npstat::GaussLegendreQuadrature::isAllowed(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussLegendreQuadrature_allowedNPonts(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< unsigned int,std::allocator< unsigned int > > result;

	if (!PyArg_ParseTuple(args,(char *)":GaussLegendreQuadrature_allowedNPonts")) SWIG_fail;
	{
	try {
	result = npstat::GaussLegendreQuadrature::allowedNPonts();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussLegendreQuadrature_minimalExactRule(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussLegendreQuadrature_minimalExactRule",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GaussLegendreQuadrature_minimalExactRule" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	{
	try {
	result = (unsigned int)npstat::GaussLegendreQuadrature::minimalExactRule(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussLegendreQuadrature_getAbscissae(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussLegendreQuadrature arg1 = (npstat::GaussLegendreQuadrature ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< double,std::allocator< double > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussLegendreQuadrature_getAbscissae",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussLegendreQuadrature, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLegendreQuadrature_getAbscissae" "', argument " "1"" of type '" "npstat::GaussLegendreQuadrature const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussLegendreQuadrature * >(argp1);
	{
	try {
	result = ((npstat::GaussLegendreQuadrature const *)arg1)->abscissae2();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussLegendreQuadrature_getWeights(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussLegendreQuadrature arg1 = (npstat::GaussLegendreQuadrature ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< double,std::allocator< double > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussLegendreQuadrature_getWeights",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussLegendreQuadrature, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLegendreQuadrature_getWeights" "', argument " "1"" of type '" "npstat::GaussLegendreQuadrature const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussLegendreQuadrature * >(argp1);
	{
	try {
	result = ((npstat::GaussLegendreQuadrature const *)arg1)->weights2();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussLegendreQuadrature_integrate__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussLegendreQuadrature arg1 = (npstat::GaussLegendreQuadrature ) 0 ;
	npstat::Functor1< double,double > *arg2 = 0 ;
	long double arg3 ;
	long double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 ;
	int res3 = 0 ;
	void *argp4 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	long double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:GaussLegendreQuadrature_integrate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussLegendreQuadrature, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLegendreQuadrature_integrate" "', argument " "1"" of type '" "npstat::GaussLegendreQuadrature const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussLegendreQuadrature * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__Functor1T_double_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussLegendreQuadrature_integrate" "', argument " "2"" of type '" "npstat::Functor1< double,double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussLegendreQuadrature_integrate" "', argument " "2"" of type '" "npstat::Functor1< double,double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::Functor1< double,double > * >(argp2);
	{
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_long_double, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussLegendreQuadrature_integrate" "', argument " "3"" of type '" "long double""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussLegendreQuadrature_integrate" "', argument " "3"" of type '" "long double""'");
	} else {
	long double * temp = reinterpret_cast< long double * >(argp3);
	arg3 = *temp;
	if (SWIG_IsNewObj(res3)) delete temp;
	}
	}
	{
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_long_double, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GaussLegendreQuadrature_integrate" "', argument " "4"" of type '" "long double""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussLegendreQuadrature_integrate" "', argument " "4"" of type '" "long double""'");
	} else {
	long double * temp = reinterpret_cast< long double * >(argp4);
	arg4 = *temp;
	if (SWIG_IsNewObj(res4)) delete temp;
	}
	}
	{
	try {
	result = (long double)((npstat::GaussLegendreQuadrature const )arg1)->SWIGTEMPLATEDISAMBIGUATOR integrate< double,double >((npstat::Functor1< double,double > const &)arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new long double(static_cast< const long double& >(result))), SWIGTYPE_p_long_double, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussLegendreQuadrature_integrate__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussLegendreQuadrature arg1 = (npstat::GaussLegendreQuadrature ) 0 ;
	npstat::Functor1< double,double > *arg2 = 0 ;
	long double arg3 ;
	long double arg4 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 ;
	int res3 = 0 ;
	void *argp4 ;
	int res4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	long double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:GaussLegendreQuadrature_integrate",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussLegendreQuadrature, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLegendreQuadrature_integrate" "', argument " "1"" of type '" "npstat::GaussLegendreQuadrature const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussLegendreQuadrature * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__Functor1T_double_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussLegendreQuadrature_integrate" "', argument " "2"" of type '" "npstat::Functor1< double,double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussLegendreQuadrature_integrate" "', argument " "2"" of type '" "npstat::Functor1< double,double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::Functor1< double,double > * >(argp2);
	{
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_long_double, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussLegendreQuadrature_integrate" "', argument " "3"" of type '" "long double""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussLegendreQuadrature_integrate" "', argument " "3"" of type '" "long double""'");
	} else {
	long double * temp = reinterpret_cast< long double * >(argp3);
	arg3 = *temp;
	if (SWIG_IsNewObj(res3)) delete temp;
	}
	}
	{
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_long_double, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GaussLegendreQuadrature_integrate" "', argument " "4"" of type '" "long double""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussLegendreQuadrature_integrate" "', argument " "4"" of type '" "long double""'");
	} else {
	long double * temp = reinterpret_cast< long double * >(argp4);
	arg4 = *temp;
	if (SWIG_IsNewObj(res4)) delete temp;
	}
	}
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GaussLegendreQuadrature_integrate" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	result = (long double)((npstat::GaussLegendreQuadrature const )arg1)->SWIGTEMPLATEDISAMBIGUATOR integrate< double,double >((npstat::Functor1< double,double > const &)arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new long double(static_cast< const long double& >(result))), SWIGTYPE_p_long_double, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussLegendreQuadrature_integrate(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__GaussLegendreQuadrature, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__Functor1T_double_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_long_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_long_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_GaussLegendreQuadrature_integrate__SWIG_2(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__GaussLegendreQuadrature, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__Functor1T_double_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_long_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_long_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_GaussLegendreQuadrature_integrate__SWIG_3(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'GaussLegendreQuadrature_integrate'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::GaussLegendreQuadrature::integrate< double,double >(npstat::Functor1< double,double > const &,long double,long double) const\n"
	" npstat::GaussLegendreQuadrature::integrate< double,double >(npstat::Functor1< double,double > const &,long double,long double,unsigned int) const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_GaussLegendreQuadrature(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussLegendreQuadrature arg1 = (npstat::GaussLegendreQuadrature ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_GaussLegendreQuadrature",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussLegendreQuadrature, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussLegendreQuadrature" "', argument " "1"" of type '" "npstat::GaussLegendreQuadrature *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussLegendreQuadrature * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject GaussLegendreQuadrature_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__GaussLegendreQuadrature, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_AbsClassicalOrthoPoly1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsClassicalOrthoPoly1D arg1 = (npstat::AbsClassicalOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_AbsClassicalOrthoPoly1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AbsClassicalOrthoPoly1D" "', argument " "1"" of type '" "npstat::AbsClassicalOrthoPoly1D *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsClassicalOrthoPoly1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsClassicalOrthoPoly1D_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsClassicalOrthoPoly1D arg1 = (npstat::AbsClassicalOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::AbsClassicalOrthoPoly1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsClassicalOrthoPoly1D_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsClassicalOrthoPoly1D_clone" "', argument " "1"" of type '" "npstat::AbsClassicalOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsClassicalOrthoPoly1D * >(argp1);
	{
	try {
	result = (npstat::AbsClassicalOrthoPoly1D )((npstat::AbsClassicalOrthoPoly1D const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsClassicalOrthoPoly1D_xmin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsClassicalOrthoPoly1D arg1 = (npstat::AbsClassicalOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsClassicalOrthoPoly1D_xmin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsClassicalOrthoPoly1D_xmin" "', argument " "1"" of type '" "npstat::AbsClassicalOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsClassicalOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::AbsClassicalOrthoPoly1D const *)arg1)->xmin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsClassicalOrthoPoly1D_xmax(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsClassicalOrthoPoly1D arg1 = (npstat::AbsClassicalOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsClassicalOrthoPoly1D_xmax",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsClassicalOrthoPoly1D_xmax" "', argument " "1"" of type '" "npstat::AbsClassicalOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsClassicalOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::AbsClassicalOrthoPoly1D const *)arg1)->xmax();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsClassicalOrthoPoly1D_maxDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsClassicalOrthoPoly1D arg1 = (npstat::AbsClassicalOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:AbsClassicalOrthoPoly1D_maxDegree",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsClassicalOrthoPoly1D_maxDegree" "', argument " "1"" of type '" "npstat::AbsClassicalOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsClassicalOrthoPoly1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::AbsClassicalOrthoPoly1D const *)arg1)->maxDegree();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsClassicalOrthoPoly1D_twopoly(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsClassicalOrthoPoly1D arg1 = (npstat::AbsClassicalOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	long double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	void *argp4 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	std::pair< long double,long double > result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:AbsClassicalOrthoPoly1D_twopoly",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsClassicalOrthoPoly1D_twopoly" "', argument " "1"" of type '" "npstat::AbsClassicalOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsClassicalOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbsClassicalOrthoPoly1D_twopoly" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbsClassicalOrthoPoly1D_twopoly" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_long_double, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AbsClassicalOrthoPoly1D_twopoly" "', argument " "4"" of type '" "long double""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbsClassicalOrthoPoly1D_twopoly" "', argument " "4"" of type '" "long double""'");
	} else {
	long double * temp = reinterpret_cast< long double * >(argp4);
	arg4 = *temp;
	if (SWIG_IsNewObj(res4)) delete temp;
	}
	}
	{
	try {
	result = ((npstat::AbsClassicalOrthoPoly1D const *)arg1)->twopoly(arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::pair< long double,long double > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsClassicalOrthoPoly1D_allpoly(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsClassicalOrthoPoly1D arg1 = (npstat::AbsClassicalOrthoPoly1D ) 0 ;
	long double arg2 ;
	long double arg3 = (long double ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:AbsClassicalOrthoPoly1D_allpoly",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsClassicalOrthoPoly1D_allpoly" "', argument " "1"" of type '" "npstat::AbsClassicalOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsClassicalOrthoPoly1D * >(argp1);
	{
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_long_double, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbsClassicalOrthoPoly1D_allpoly" "', argument " "2"" of type '" "long double""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbsClassicalOrthoPoly1D_allpoly" "', argument " "2"" of type '" "long double""'");
	} else {
	long double * temp = reinterpret_cast< long double * >(argp2);
	arg2 = *temp;
	if (SWIG_IsNewObj(res2)) delete temp;
	}
	}
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_long_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbsClassicalOrthoPoly1D_allpoly" "', argument " "3"" of type '" "long double *""'");
	}
	arg3 = reinterpret_cast< long double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbsClassicalOrthoPoly1D_allpoly" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	((npstat::AbsClassicalOrthoPoly1D const *)arg1)->allpoly(arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsClassicalOrthoPoly1D_series(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsClassicalOrthoPoly1D arg1 = (npstat::AbsClassicalOrthoPoly1D ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:AbsClassicalOrthoPoly1D_series",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsClassicalOrthoPoly1D_series" "', argument " "1"" of type '" "npstat::AbsClassicalOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsClassicalOrthoPoly1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbsClassicalOrthoPoly1D_series" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbsClassicalOrthoPoly1D_series" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbsClassicalOrthoPoly1D_series" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	result = (double)((npstat::AbsClassicalOrthoPoly1D const )arg1)->series((double const )arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsClassicalOrthoPoly1D_integratePoly(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsClassicalOrthoPoly1D arg1 = (npstat::AbsClassicalOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:AbsClassicalOrthoPoly1D_integratePoly",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsClassicalOrthoPoly1D_integratePoly" "', argument " "1"" of type '" "npstat::AbsClassicalOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsClassicalOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbsClassicalOrthoPoly1D_integratePoly" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbsClassicalOrthoPoly1D_integratePoly" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::AbsClassicalOrthoPoly1D const *)arg1)->integratePoly(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsClassicalOrthoPoly1D_jointIntegral(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsClassicalOrthoPoly1D arg1 = (npstat::AbsClassicalOrthoPoly1D ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:AbsClassicalOrthoPoly1D_jointIntegral",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsClassicalOrthoPoly1D_jointIntegral" "', argument " "1"" of type '" "npstat::AbsClassicalOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsClassicalOrthoPoly1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbsClassicalOrthoPoly1D_jointIntegral" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbsClassicalOrthoPoly1D_jointIntegral" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::AbsClassicalOrthoPoly1D const )arg1)->jointIntegral((unsigned int const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsClassicalOrthoPoly1D_weight(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsClassicalOrthoPoly1D arg1 = (npstat::AbsClassicalOrthoPoly1D ) 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:AbsClassicalOrthoPoly1D_weight",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsClassicalOrthoPoly1D_weight" "', argument " "1"" of type '" "npstat::AbsClassicalOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsClassicalOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbsClassicalOrthoPoly1D_weight" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (double)((npstat::AbsClassicalOrthoPoly1D const *)arg1)->weight2(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsClassicalOrthoPoly1D_poly(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsClassicalOrthoPoly1D arg1 = (npstat::AbsClassicalOrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:AbsClassicalOrthoPoly1D_poly",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsClassicalOrthoPoly1D_poly" "', argument " "1"" of type '" "npstat::AbsClassicalOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsClassicalOrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbsClassicalOrthoPoly1D_poly" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbsClassicalOrthoPoly1D_poly" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (double)((npstat::AbsClassicalOrthoPoly1D const *)arg1)->poly2(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_AbsClassicalOrthoPoly1D_empiricalKroneckerDelta(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsClassicalOrthoPoly1D arg1 = (npstat::AbsClassicalOrthoPoly1D ) 0 ;
	npstat::GaussLegendreQuadrature *arg2 = 0 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:AbsClassicalOrthoPoly1D_empiricalKroneckerDelta",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbsClassicalOrthoPoly1D_empiricalKroneckerDelta" "', argument " "1"" of type '" "npstat::AbsClassicalOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsClassicalOrthoPoly1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__GaussLegendreQuadrature, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbsClassicalOrthoPoly1D_empiricalKroneckerDelta" "', argument " "2"" of type '" "npstat::GaussLegendreQuadrature const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbsClassicalOrthoPoly1D_empiricalKroneckerDelta" "', argument " "2"" of type '" "npstat::GaussLegendreQuadrature const &""'");
	}
	arg2 = reinterpret_cast< npstat::GaussLegendreQuadrature * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AbsClassicalOrthoPoly1D_empiricalKroneckerDelta" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbsClassicalOrthoPoly1D_empiricalKroneckerDelta" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	result = (double)((npstat::AbsClassicalOrthoPoly1D const )arg1)->SWIGTEMPLATEDISAMBIGUATOR empiricalKroneckerDelta< npstat::GaussLegendreQuadrature >((npstat::GaussLegendreQuadrature const &)arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject AbsClassicalOrthoPoly1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_OrthoPoly1DWeight__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsClassicalOrthoPoly1D *arg1 = 0 ;
	long double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::OrthoPoly1DWeight *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_OrthoPoly1DWeight",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrthoPoly1DWeight" "', argument " "1"" of type '" "npstat::AbsClassicalOrthoPoly1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrthoPoly1DWeight" "', argument " "1"" of type '" "npstat::AbsClassicalOrthoPoly1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsClassicalOrthoPoly1D * >(argp1);
	{
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_long_double, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OrthoPoly1DWeight" "', argument " "2"" of type '" "long double const""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrthoPoly1DWeight" "', argument " "2"" of type '" "long double const""'");
	} else {
	long double * temp = reinterpret_cast< long double * >(argp2);
	arg2 = *temp;
	if (SWIG_IsNewObj(res2)) delete temp;
	}
	}
	{
	try {
	result = (npstat::OrthoPoly1DWeight )new npstat::OrthoPoly1DWeight((npstat::AbsClassicalOrthoPoly1D const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__OrthoPoly1DWeight, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_OrthoPoly1DWeight__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsClassicalOrthoPoly1D *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::OrthoPoly1DWeight *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_OrthoPoly1DWeight",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrthoPoly1DWeight" "', argument " "1"" of type '" "npstat::AbsClassicalOrthoPoly1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrthoPoly1DWeight" "', argument " "1"" of type '" "npstat::AbsClassicalOrthoPoly1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsClassicalOrthoPoly1D * >(argp1);
	{
	try {
	result = (npstat::OrthoPoly1DWeight )new npstat::OrthoPoly1DWeight((npstat::AbsClassicalOrthoPoly1D const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__OrthoPoly1DWeight, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_OrthoPoly1DWeight(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_OrthoPoly1DWeight__SWIG_1(self, args);
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsClassicalOrthoPoly1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_long_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_OrthoPoly1DWeight__SWIG_0(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrthoPoly1DWeight'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::OrthoPoly1DWeight::OrthoPoly1DWeight(npstat::AbsClassicalOrthoPoly1D const &,long double const)\n"
	" npstat::OrthoPoly1DWeight::OrthoPoly1DWeight(npstat::AbsClassicalOrthoPoly1D const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_OrthoPoly1DWeight(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1DWeight arg1 = (npstat::OrthoPoly1DWeight ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_OrthoPoly1DWeight",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1DWeight, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrthoPoly1DWeight" "', argument " "1"" of type '" "npstat::OrthoPoly1DWeight *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1DWeight * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPoly1DWeight___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1DWeight arg1 = (npstat::OrthoPoly1DWeight ) 0 ;
	long double *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	long double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:OrthoPoly1DWeight___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1DWeight, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPoly1DWeight___call__" "', argument " "1"" of type '" "npstat::OrthoPoly1DWeight const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1DWeight * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_long_double, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OrthoPoly1DWeight___call__" "', argument " "2"" of type '" "long double const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OrthoPoly1DWeight___call__" "', argument " "2"" of type '" "long double const &""'");
	}
	arg2 = reinterpret_cast< long double * >(argp2);
	{
	try {
	result = (long double)((npstat::OrthoPoly1DWeight const )arg1)->operator ()((long double const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new long double(static_cast< const long double& >(result))), SWIGTYPE_p_long_double, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject OrthoPoly1DWeight_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__OrthoPoly1DWeight, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_OrthoPoly1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_OrthoPoly1D")) SWIG_fail;
	{
	try {
	result = (npstat::OrthoPoly1D *)new npstat::OrthoPoly1D();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__OrthoPoly1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_OrthoPoly1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::OrthoPoly1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_OrthoPoly1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OrthoPoly1D" "', argument " "1"" of type '" "npstat::OrthoPoly1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OrthoPoly1D" "', argument " "1"" of type '" "npstat::OrthoPoly1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1D * >(argp1);
	{
	try {
	result = (npstat::OrthoPoly1D )new npstat::OrthoPoly1D((npstat::OrthoPoly1D const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__OrthoPoly1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_OrthoPoly1D__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	double arg4 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::OrthoPoly1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_OrthoPoly1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_OrthoPoly1D" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OrthoPoly1D" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OrthoPoly1D" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_OrthoPoly1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	result = (npstat::OrthoPoly1D )new npstat::OrthoPoly1D(arg1,(double const )arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__OrthoPoly1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_OrthoPoly1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 0) {
	return _wrap_new_OrthoPoly1D__SWIG_0(self, args);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__OrthoPoly1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_OrthoPoly1D__SWIG_1(self, args);
	}
	}
	if (argc == 4) {
	int _v;
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_OrthoPoly1D__SWIG_2(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_OrthoPoly1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::OrthoPoly1D::OrthoPoly1D()\n"
	" npstat::OrthoPoly1D::OrthoPoly1D(npstat::OrthoPoly1D const &)\n"
	" npstat::OrthoPoly1D::OrthoPoly1D(unsigned int,double const *,unsigned int,double)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_OrthoPoly1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D arg1 = (npstat::OrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_OrthoPoly1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OrthoPoly1D" "', argument " "1"" of type '" "npstat::OrthoPoly1D *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPoly1D_length(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D arg1 = (npstat::OrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:OrthoPoly1D_length",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPoly1D_length" "', argument " "1"" of type '" "npstat::OrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::OrthoPoly1D const *)arg1)->length();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPoly1D_maxDegree(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D arg1 = (npstat::OrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:OrthoPoly1D_maxDegree",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPoly1D_maxDegree" "', argument " "1"" of type '" "npstat::OrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::OrthoPoly1D const *)arg1)->maxDegree();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPoly1D_step(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D arg1 = (npstat::OrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:OrthoPoly1D_step",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPoly1D_step" "', argument " "1"" of type '" "npstat::OrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::OrthoPoly1D const *)arg1)->step();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPoly1D___eq__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D arg1 = (npstat::OrthoPoly1D ) 0 ;
	npstat::OrthoPoly1D *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:OrthoPoly1D___eq__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPoly1D___eq__" "', argument " "1"" of type '" "npstat::OrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OrthoPoly1D___eq__" "', argument " "2"" of type '" "npstat::OrthoPoly1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OrthoPoly1D___eq__" "', argument " "2"" of type '" "npstat::OrthoPoly1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::OrthoPoly1D * >(argp2);
	{
	try {
	result = (bool)((npstat::OrthoPoly1D const )arg1)->operator ==((npstat::OrthoPoly1D const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPoly1D___ne__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D arg1 = (npstat::OrthoPoly1D ) 0 ;
	npstat::OrthoPoly1D *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:OrthoPoly1D___ne__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPoly1D___ne__" "', argument " "1"" of type '" "npstat::OrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OrthoPoly1D___ne__" "', argument " "2"" of type '" "npstat::OrthoPoly1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OrthoPoly1D___ne__" "', argument " "2"" of type '" "npstat::OrthoPoly1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::OrthoPoly1D * >(argp2);
	{
	try {
	result = (bool)((npstat::OrthoPoly1D const )arg1)->operator !=((npstat::OrthoPoly1D const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPoly1D_weight(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D arg1 = (npstat::OrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:OrthoPoly1D_weight",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPoly1D_weight" "', argument " "1"" of type '" "npstat::OrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthoPoly1D_weight" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (double)((npstat::OrthoPoly1D const *)arg1)->weight(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPoly1D_poly(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D arg1 = (npstat::OrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:OrthoPoly1D_poly",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPoly1D_poly" "', argument " "1"" of type '" "npstat::OrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthoPoly1D_poly" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OrthoPoly1D_poly" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::OrthoPoly1D const *)arg1)->poly(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPoly1D_polyTimesWeight(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D arg1 = (npstat::OrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:OrthoPoly1D_polyTimesWeight",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPoly1D_polyTimesWeight" "', argument " "1"" of type '" "npstat::OrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthoPoly1D_polyTimesWeight" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OrthoPoly1D_polyTimesWeight" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::OrthoPoly1D const *)arg1)->polyTimesWeight(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPoly1D_series(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D arg1 = (npstat::OrthoPoly1D ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:OrthoPoly1D_series",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPoly1D_series" "', argument " "1"" of type '" "npstat::OrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OrthoPoly1D_series" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OrthoPoly1D_series" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OrthoPoly1D_series" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	result = (double)((npstat::OrthoPoly1D const )arg1)->series((double const )arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPoly1D_calculateCoeffs(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D arg1 = (npstat::OrthoPoly1D ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	double arg4 = (double ) 0 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:OrthoPoly1D_calculateCoeffs",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPoly1D_calculateCoeffs" "', argument " "1"" of type '" "npstat::OrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OrthoPoly1D_calculateCoeffs" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OrthoPoly1D_calculateCoeffs" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OrthoPoly1D_calculateCoeffs" "', argument " "4"" of type '" "double *""'");
	}
	arg4 = reinterpret_cast< double * >(argp4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "OrthoPoly1D_calculateCoeffs" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	((npstat::OrthoPoly1D const )arg1)->calculateCoeffs((double const )arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPoly1D_empiricalKroneckerDelta(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D arg1 = (npstat::OrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:OrthoPoly1D_empiricalKroneckerDelta",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPoly1D_empiricalKroneckerDelta" "', argument " "1"" of type '" "npstat::OrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthoPoly1D_empiricalKroneckerDelta" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OrthoPoly1D_empiricalKroneckerDelta" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::OrthoPoly1D const *)arg1)->empiricalKroneckerDelta(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPoly1D_weightExpansionCoeffs(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D arg1 = (npstat::OrthoPoly1D ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:OrthoPoly1D_weightExpansionCoeffs",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPoly1D_weightExpansionCoeffs" "', argument " "1"" of type '" "npstat::OrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OrthoPoly1D_weightExpansionCoeffs" "', argument " "2"" of type '" "double *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OrthoPoly1D_weightExpansionCoeffs" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	((npstat::OrthoPoly1D const *)arg1)->weightExpansionCoeffs(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPoly1D_weightExpansionCovariance(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D arg1 = (npstat::OrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:OrthoPoly1D_weightExpansionCovariance",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPoly1D_weightExpansionCovariance" "', argument " "1"" of type '" "npstat::OrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthoPoly1D_weightExpansionCovariance" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OrthoPoly1D_weightExpansionCovariance" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::OrthoPoly1D const *)arg1)->weightExpansionCovariance(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPoly1D_unweightedPolyProduct(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D arg1 = (npstat::OrthoPoly1D ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:OrthoPoly1D_unweightedPolyProduct",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPoly1D_unweightedPolyProduct" "', argument " "1"" of type '" "npstat::OrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OrthoPoly1D_unweightedPolyProduct" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OrthoPoly1D_unweightedPolyProduct" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (double)((npstat::OrthoPoly1D const *)arg1)->unweightedPolyProduct(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_OrthoPoly1D_linearFilter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::OrthoPoly1D arg1 = (npstat::OrthoPoly1D ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	double arg5 = (double ) 0 ;
	unsigned int arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:OrthoPoly1D_linearFilter",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__OrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OrthoPoly1D_linearFilter" "', argument " "1"" of type '" "npstat::OrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::OrthoPoly1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OrthoPoly1D_linearFilter" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OrthoPoly1D_linearFilter" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "OrthoPoly1D_linearFilter" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OrthoPoly1D_linearFilter" "', argument " "5"" of type '" "double *""'");
	}
	arg5 = reinterpret_cast< double * >(argp5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "OrthoPoly1D_linearFilter" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	{
	try {
	((npstat::OrthoPoly1D const )arg1)->SWIGTEMPLATEDISAMBIGUATOR linearFilter< double >((double const )arg2,arg3,arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject OrthoPoly1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__OrthoPoly1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_LegendreOrthoPoly1D_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LegendreOrthoPoly1D arg1 = (npstat::LegendreOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::LegendreOrthoPoly1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LegendreOrthoPoly1D_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LegendreOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegendreOrthoPoly1D_clone" "', argument " "1"" of type '" "npstat::LegendreOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LegendreOrthoPoly1D * >(argp1);
	{
	try {
	result = (npstat::LegendreOrthoPoly1D )((npstat::LegendreOrthoPoly1D const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LegendreOrthoPoly1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_LegendreOrthoPoly1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LegendreOrthoPoly1D arg1 = (npstat::LegendreOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LegendreOrthoPoly1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LegendreOrthoPoly1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LegendreOrthoPoly1D" "', argument " "1"" of type '" "npstat::LegendreOrthoPoly1D *""'");
	}
	arg1 = reinterpret_cast< npstat::LegendreOrthoPoly1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LegendreOrthoPoly1D_xmin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LegendreOrthoPoly1D arg1 = (npstat::LegendreOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:LegendreOrthoPoly1D_xmin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LegendreOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegendreOrthoPoly1D_xmin" "', argument " "1"" of type '" "npstat::LegendreOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LegendreOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::LegendreOrthoPoly1D const *)arg1)->xmin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LegendreOrthoPoly1D_xmax(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LegendreOrthoPoly1D arg1 = (npstat::LegendreOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:LegendreOrthoPoly1D_xmax",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__LegendreOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LegendreOrthoPoly1D_xmax" "', argument " "1"" of type '" "npstat::LegendreOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::LegendreOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::LegendreOrthoPoly1D const *)arg1)->xmax();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LegendreOrthoPoly1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::LegendreOrthoPoly1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_LegendreOrthoPoly1D")) SWIG_fail;
	{
	try {
	result = (npstat::LegendreOrthoPoly1D *)new npstat::LegendreOrthoPoly1D();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__LegendreOrthoPoly1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject LegendreOrthoPoly1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__LegendreOrthoPoly1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_ShiftedLegendreOrthoPoly1D_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ShiftedLegendreOrthoPoly1D arg1 = (npstat::ShiftedLegendreOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ShiftedLegendreOrthoPoly1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:ShiftedLegendreOrthoPoly1D_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ShiftedLegendreOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShiftedLegendreOrthoPoly1D_clone" "', argument " "1"" of type '" "npstat::ShiftedLegendreOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ShiftedLegendreOrthoPoly1D * >(argp1);
	{
	try {
	result = (npstat::ShiftedLegendreOrthoPoly1D )((npstat::ShiftedLegendreOrthoPoly1D const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ShiftedLegendreOrthoPoly1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ShiftedLegendreOrthoPoly1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ShiftedLegendreOrthoPoly1D arg1 = (npstat::ShiftedLegendreOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ShiftedLegendreOrthoPoly1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ShiftedLegendreOrthoPoly1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ShiftedLegendreOrthoPoly1D" "', argument " "1"" of type '" "npstat::ShiftedLegendreOrthoPoly1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ShiftedLegendreOrthoPoly1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ShiftedLegendreOrthoPoly1D_xmin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ShiftedLegendreOrthoPoly1D arg1 = (npstat::ShiftedLegendreOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:ShiftedLegendreOrthoPoly1D_xmin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ShiftedLegendreOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShiftedLegendreOrthoPoly1D_xmin" "', argument " "1"" of type '" "npstat::ShiftedLegendreOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ShiftedLegendreOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::ShiftedLegendreOrthoPoly1D const *)arg1)->xmin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ShiftedLegendreOrthoPoly1D_xmax(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ShiftedLegendreOrthoPoly1D arg1 = (npstat::ShiftedLegendreOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:ShiftedLegendreOrthoPoly1D_xmax",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ShiftedLegendreOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShiftedLegendreOrthoPoly1D_xmax" "', argument " "1"" of type '" "npstat::ShiftedLegendreOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ShiftedLegendreOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::ShiftedLegendreOrthoPoly1D const *)arg1)->xmax();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ShiftedLegendreOrthoPoly1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ShiftedLegendreOrthoPoly1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_JacobiOrthoPoly1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::JacobiOrthoPoly1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_JacobiOrthoPoly1D",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JacobiOrthoPoly1D" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_JacobiOrthoPoly1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (npstat::JacobiOrthoPoly1D *)new npstat::JacobiOrthoPoly1D(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__JacobiOrthoPoly1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_JacobiOrthoPoly1D_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::JacobiOrthoPoly1D arg1 = (npstat::JacobiOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::JacobiOrthoPoly1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:JacobiOrthoPoly1D_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__JacobiOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JacobiOrthoPoly1D_clone" "', argument " "1"" of type '" "npstat::JacobiOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::JacobiOrthoPoly1D * >(argp1);
	{
	try {
	result = (npstat::JacobiOrthoPoly1D )((npstat::JacobiOrthoPoly1D const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__JacobiOrthoPoly1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_JacobiOrthoPoly1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::JacobiOrthoPoly1D arg1 = (npstat::JacobiOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_JacobiOrthoPoly1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__JacobiOrthoPoly1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JacobiOrthoPoly1D" "', argument " "1"" of type '" "npstat::JacobiOrthoPoly1D *""'");
	}
	arg1 = reinterpret_cast< npstat::JacobiOrthoPoly1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_JacobiOrthoPoly1D_alpha(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::JacobiOrthoPoly1D arg1 = (npstat::JacobiOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:JacobiOrthoPoly1D_alpha",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__JacobiOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JacobiOrthoPoly1D_alpha" "', argument " "1"" of type '" "npstat::JacobiOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::JacobiOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::JacobiOrthoPoly1D const *)arg1)->alpha();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_JacobiOrthoPoly1D_beta(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::JacobiOrthoPoly1D arg1 = (npstat::JacobiOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:JacobiOrthoPoly1D_beta",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__JacobiOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JacobiOrthoPoly1D_beta" "', argument " "1"" of type '" "npstat::JacobiOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::JacobiOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::JacobiOrthoPoly1D const *)arg1)->beta();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_JacobiOrthoPoly1D_xmin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::JacobiOrthoPoly1D arg1 = (npstat::JacobiOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:JacobiOrthoPoly1D_xmin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__JacobiOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JacobiOrthoPoly1D_xmin" "', argument " "1"" of type '" "npstat::JacobiOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::JacobiOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::JacobiOrthoPoly1D const *)arg1)->xmin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_JacobiOrthoPoly1D_xmax(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::JacobiOrthoPoly1D arg1 = (npstat::JacobiOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:JacobiOrthoPoly1D_xmax",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__JacobiOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JacobiOrthoPoly1D_xmax" "', argument " "1"" of type '" "npstat::JacobiOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::JacobiOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::JacobiOrthoPoly1D const *)arg1)->xmax();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject JacobiOrthoPoly1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__JacobiOrthoPoly1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_ChebyshevOrthoPoly1st_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ChebyshevOrthoPoly1st arg1 = (npstat::ChebyshevOrthoPoly1st ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ChebyshevOrthoPoly1st *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:ChebyshevOrthoPoly1st_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ChebyshevOrthoPoly1st, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChebyshevOrthoPoly1st_clone" "', argument " "1"" of type '" "npstat::ChebyshevOrthoPoly1st const *""'");
	}
	arg1 = reinterpret_cast< npstat::ChebyshevOrthoPoly1st * >(argp1);
	{
	try {
	result = (npstat::ChebyshevOrthoPoly1st )((npstat::ChebyshevOrthoPoly1st const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ChebyshevOrthoPoly1st, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ChebyshevOrthoPoly1st(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ChebyshevOrthoPoly1st arg1 = (npstat::ChebyshevOrthoPoly1st ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ChebyshevOrthoPoly1st",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ChebyshevOrthoPoly1st, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChebyshevOrthoPoly1st" "', argument " "1"" of type '" "npstat::ChebyshevOrthoPoly1st *""'");
	}
	arg1 = reinterpret_cast< npstat::ChebyshevOrthoPoly1st * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ChebyshevOrthoPoly1st_xmin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ChebyshevOrthoPoly1st arg1 = (npstat::ChebyshevOrthoPoly1st ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:ChebyshevOrthoPoly1st_xmin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ChebyshevOrthoPoly1st, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChebyshevOrthoPoly1st_xmin" "', argument " "1"" of type '" "npstat::ChebyshevOrthoPoly1st const *""'");
	}
	arg1 = reinterpret_cast< npstat::ChebyshevOrthoPoly1st * >(argp1);
	{
	try {
	result = (double)((npstat::ChebyshevOrthoPoly1st const *)arg1)->xmin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ChebyshevOrthoPoly1st_xmax(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ChebyshevOrthoPoly1st arg1 = (npstat::ChebyshevOrthoPoly1st ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:ChebyshevOrthoPoly1st_xmax",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ChebyshevOrthoPoly1st, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChebyshevOrthoPoly1st_xmax" "', argument " "1"" of type '" "npstat::ChebyshevOrthoPoly1st const *""'");
	}
	arg1 = reinterpret_cast< npstat::ChebyshevOrthoPoly1st * >(argp1);
	{
	try {
	result = (double)((npstat::ChebyshevOrthoPoly1st const *)arg1)->xmax();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ChebyshevOrthoPoly1st_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ChebyshevOrthoPoly1st, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_ChebyshevOrthoPoly2nd_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ChebyshevOrthoPoly2nd arg1 = (npstat::ChebyshevOrthoPoly2nd ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ChebyshevOrthoPoly2nd *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:ChebyshevOrthoPoly2nd_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ChebyshevOrthoPoly2nd, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChebyshevOrthoPoly2nd_clone" "', argument " "1"" of type '" "npstat::ChebyshevOrthoPoly2nd const *""'");
	}
	arg1 = reinterpret_cast< npstat::ChebyshevOrthoPoly2nd * >(argp1);
	{
	try {
	result = (npstat::ChebyshevOrthoPoly2nd )((npstat::ChebyshevOrthoPoly2nd const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ChebyshevOrthoPoly2nd, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ChebyshevOrthoPoly2nd(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ChebyshevOrthoPoly2nd arg1 = (npstat::ChebyshevOrthoPoly2nd ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ChebyshevOrthoPoly2nd",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ChebyshevOrthoPoly2nd, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ChebyshevOrthoPoly2nd" "', argument " "1"" of type '" "npstat::ChebyshevOrthoPoly2nd *""'");
	}
	arg1 = reinterpret_cast< npstat::ChebyshevOrthoPoly2nd * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ChebyshevOrthoPoly2nd_xmin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ChebyshevOrthoPoly2nd arg1 = (npstat::ChebyshevOrthoPoly2nd ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:ChebyshevOrthoPoly2nd_xmin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ChebyshevOrthoPoly2nd, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChebyshevOrthoPoly2nd_xmin" "', argument " "1"" of type '" "npstat::ChebyshevOrthoPoly2nd const *""'");
	}
	arg1 = reinterpret_cast< npstat::ChebyshevOrthoPoly2nd * >(argp1);
	{
	try {
	result = (double)((npstat::ChebyshevOrthoPoly2nd const *)arg1)->xmin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ChebyshevOrthoPoly2nd_xmax(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ChebyshevOrthoPoly2nd arg1 = (npstat::ChebyshevOrthoPoly2nd ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:ChebyshevOrthoPoly2nd_xmax",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ChebyshevOrthoPoly2nd, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChebyshevOrthoPoly2nd_xmax" "', argument " "1"" of type '" "npstat::ChebyshevOrthoPoly2nd const *""'");
	}
	arg1 = reinterpret_cast< npstat::ChebyshevOrthoPoly2nd * >(argp1);
	{
	try {
	result = (double)((npstat::ChebyshevOrthoPoly2nd const *)arg1)->xmax();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ChebyshevOrthoPoly2nd_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ChebyshevOrthoPoly2nd, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_HermiteProbOrthoPoly1D_clone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HermiteProbOrthoPoly1D arg1 = (npstat::HermiteProbOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::HermiteProbOrthoPoly1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:HermiteProbOrthoPoly1D_clone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__HermiteProbOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HermiteProbOrthoPoly1D_clone" "', argument " "1"" of type '" "npstat::HermiteProbOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::HermiteProbOrthoPoly1D * >(argp1);
	{
	try {
	result = (npstat::HermiteProbOrthoPoly1D )((npstat::HermiteProbOrthoPoly1D const )arg1)->clone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__HermiteProbOrthoPoly1D, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_HermiteProbOrthoPoly1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HermiteProbOrthoPoly1D arg1 = (npstat::HermiteProbOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_HermiteProbOrthoPoly1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__HermiteProbOrthoPoly1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HermiteProbOrthoPoly1D" "', argument " "1"" of type '" "npstat::HermiteProbOrthoPoly1D *""'");
	}
	arg1 = reinterpret_cast< npstat::HermiteProbOrthoPoly1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_HermiteProbOrthoPoly1D_xmin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HermiteProbOrthoPoly1D arg1 = (npstat::HermiteProbOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:HermiteProbOrthoPoly1D_xmin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__HermiteProbOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HermiteProbOrthoPoly1D_xmin" "', argument " "1"" of type '" "npstat::HermiteProbOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::HermiteProbOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::HermiteProbOrthoPoly1D const *)arg1)->xmin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_HermiteProbOrthoPoly1D_xmax(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HermiteProbOrthoPoly1D arg1 = (npstat::HermiteProbOrthoPoly1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:HermiteProbOrthoPoly1D_xmax",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__HermiteProbOrthoPoly1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HermiteProbOrthoPoly1D_xmax" "', argument " "1"" of type '" "npstat::HermiteProbOrthoPoly1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::HermiteProbOrthoPoly1D * >(argp1);
	{
	try {
	result = (double)((npstat::HermiteProbOrthoPoly1D const *)arg1)->xmax();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject HermiteProbOrthoPoly1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__HermiteProbOrthoPoly1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_DoubleDoubleAbsArrayProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< double,double > arg1 = (npstat::AbsArrayProjector< double,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleDoubleAbsArrayProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_double_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleDoubleAbsArrayProjector" "', argument " "1"" of type '" "npstat::AbsArrayProjector< double,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< double,double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDoubleAbsArrayProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< double,double > arg1 = (npstat::AbsArrayProjector< double,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleDoubleAbsArrayProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_double_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleAbsArrayProjector_clear" "', argument " "1"" of type '" "npstat::AbsArrayProjector< double,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< double,double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDoubleAbsArrayProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< double,double > arg1 = (npstat::AbsArrayProjector< double,double > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	unsigned long arg4 ;
	double *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned long val4 ;
	int ecode4 = 0 ;
	double temp5 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:DoubleDoubleAbsArrayProjector_process",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_double_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleAbsArrayProjector_process" "', argument " "1"" of type '" "npstat::AbsArrayProjector< double,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< double,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleDoubleAbsArrayProjector_process" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleDoubleAbsArrayProjector_process" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleDoubleAbsArrayProjector_process" "', argument " "4"" of type '" "unsigned long""'");
	}
	arg4 = static_cast< unsigned long >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DoubleDoubleAbsArrayProjector_process" "', argument " "5"" of type '" "double""'");
	}
	temp5 = static_cast< double >(val5);
	arg5 = &temp5;
	{
	try {
	(arg1)->process((unsigned int const )arg2,arg3,arg4,(double const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleDoubleAbsArrayProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< double,double > arg1 = (npstat::AbsArrayProjector< double,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleDoubleAbsArrayProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_double_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleAbsArrayProjector_result" "', argument " "1"" of type '" "npstat::AbsArrayProjector< double,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< double,double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleDoubleAbsArrayProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsArrayProjectorT_double_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_FloatFloatAbsArrayProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< float,float > arg1 = (npstat::AbsArrayProjector< float,float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatFloatAbsArrayProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_float_float_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatFloatAbsArrayProjector" "', argument " "1"" of type '" "npstat::AbsArrayProjector< float,float > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< float,float > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatFloatAbsArrayProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< float,float > arg1 = (npstat::AbsArrayProjector< float,float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatFloatAbsArrayProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_float_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatFloatAbsArrayProjector_clear" "', argument " "1"" of type '" "npstat::AbsArrayProjector< float,float > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< float,float > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatFloatAbsArrayProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< float,float > arg1 = (npstat::AbsArrayProjector< float,float > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	unsigned long arg4 ;
	float *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned long val4 ;
	int ecode4 = 0 ;
	float temp5 ;
	float val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:FloatFloatAbsArrayProjector_process",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_float_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatFloatAbsArrayProjector_process" "', argument " "1"" of type '" "npstat::AbsArrayProjector< float,float > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< float,float > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatFloatAbsArrayProjector_process" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatFloatAbsArrayProjector_process" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatFloatAbsArrayProjector_process" "', argument " "4"" of type '" "unsigned long""'");
	}
	arg4 = static_cast< unsigned long >(val4);
	ecode5 = SWIG_AsVal_float(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FloatFloatAbsArrayProjector_process" "', argument " "5"" of type '" "float""'");
	}
	temp5 = static_cast< float >(val5);
	arg5 = &temp5;
	{
	try {
	(arg1)->process((unsigned int const )arg2,arg3,arg4,(float const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatFloatAbsArrayProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< float,float > arg1 = (npstat::AbsArrayProjector< float,float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatFloatAbsArrayProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_float_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatFloatAbsArrayProjector_result" "', argument " "1"" of type '" "npstat::AbsArrayProjector< float,float > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< float,float > * >(argp1);
	{
	try {
	result = (float)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatFloatAbsArrayProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsArrayProjectorT_float_float_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_IntIntAbsArrayProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< int,int > arg1 = (npstat::AbsArrayProjector< int,int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_IntIntAbsArrayProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_int_int_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntIntAbsArrayProjector" "', argument " "1"" of type '" "npstat::AbsArrayProjector< int,int > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< int,int > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntIntAbsArrayProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< int,int > arg1 = (npstat::AbsArrayProjector< int,int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:IntIntAbsArrayProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_int_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntAbsArrayProjector_clear" "', argument " "1"" of type '" "npstat::AbsArrayProjector< int,int > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< int,int > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntIntAbsArrayProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< int,int > arg1 = (npstat::AbsArrayProjector< int,int > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	unsigned long arg4 ;
	int *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned long val4 ;
	int ecode4 = 0 ;
	int temp5 ;
	int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:IntIntAbsArrayProjector_process",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_int_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntAbsArrayProjector_process" "', argument " "1"" of type '" "npstat::AbsArrayProjector< int,int > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< int,int > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntIntAbsArrayProjector_process" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntIntAbsArrayProjector_process" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IntIntAbsArrayProjector_process" "', argument " "4"" of type '" "unsigned long""'");
	}
	arg4 = static_cast< unsigned long >(val4);
	ecode5 = SWIG_AsVal_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IntIntAbsArrayProjector_process" "', argument " "5"" of type '" "int""'");
	}
	temp5 = static_cast< int >(val5);
	arg5 = &temp5;
	{
	try {
	(arg1)->process((unsigned int const )arg2,arg3,arg4,(int const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntIntAbsArrayProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< int,int > arg1 = (npstat::AbsArrayProjector< int,int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	int result;

	if (!PyArg_ParseTuple(args,(char *)"O:IntIntAbsArrayProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_int_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntAbsArrayProjector_result" "', argument " "1"" of type '" "npstat::AbsArrayProjector< int,int > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< int,int > * >(argp1);
	{
	try {
	result = (int)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_int(static_cast< int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject IntIntAbsArrayProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsArrayProjectorT_int_int_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_LLongLLongAbsArrayProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< long long,long long > arg1 = (npstat::AbsArrayProjector< long long,long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LLongLLongAbsArrayProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_long_long_long_long_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LLongLLongAbsArrayProjector" "', argument " "1"" of type '" "npstat::AbsArrayProjector< long long,long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< long long,long long > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongLLongAbsArrayProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< long long,long long > arg1 = (npstat::AbsArrayProjector< long long,long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongLLongAbsArrayProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_long_long_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongLLongAbsArrayProjector_clear" "', argument " "1"" of type '" "npstat::AbsArrayProjector< long long,long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< long long,long long > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongLLongAbsArrayProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< long long,long long > arg1 = (npstat::AbsArrayProjector< long long,long long > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	unsigned long arg4 ;
	long long *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned long val4 ;
	int ecode4 = 0 ;
	long long temp5 ;
	long long val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:LLongLLongAbsArrayProjector_process",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_long_long_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongLLongAbsArrayProjector_process" "', argument " "1"" of type '" "npstat::AbsArrayProjector< long long,long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< long long,long long > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LLongLLongAbsArrayProjector_process" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LLongLLongAbsArrayProjector_process" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LLongLLongAbsArrayProjector_process" "', argument " "4"" of type '" "unsigned long""'");
	}
	arg4 = static_cast< unsigned long >(val4);
	ecode5 = SWIG_AsVal_long_SS_long(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LLongLLongAbsArrayProjector_process" "', argument " "5"" of type '" "long long""'");
	}
	temp5 = static_cast< long long >(val5);
	arg5 = &temp5;
	{
	try {
	(arg1)->process((unsigned int const )arg2,arg3,arg4,(long long const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongLLongAbsArrayProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< long long,long long > arg1 = (npstat::AbsArrayProjector< long long,long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	long long result;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongLLongAbsArrayProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_long_long_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongLLongAbsArrayProjector_result" "', argument " "1"" of type '" "npstat::AbsArrayProjector< long long,long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< long long,long long > * >(argp1);
	{
	try {
	result = (long long)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject LLongLLongAbsArrayProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsArrayProjectorT_long_long_long_long_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_UCharUCharAbsArrayProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< unsigned char,unsigned char > arg1 = (npstat::AbsArrayProjector< unsigned char,unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_UCharUCharAbsArrayProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_unsigned_char_unsigned_char_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UCharUCharAbsArrayProjector" "', argument " "1"" of type '" "npstat::AbsArrayProjector< unsigned char,unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< unsigned char,unsigned char > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharUCharAbsArrayProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< unsigned char,unsigned char > arg1 = (npstat::AbsArrayProjector< unsigned char,unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharUCharAbsArrayProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_unsigned_char_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharUCharAbsArrayProjector_clear" "', argument " "1"" of type '" "npstat::AbsArrayProjector< unsigned char,unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< unsigned char,unsigned char > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharUCharAbsArrayProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< unsigned char,unsigned char > arg1 = (npstat::AbsArrayProjector< unsigned char,unsigned char > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	unsigned long arg4 ;
	unsigned char *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned long val4 ;
	int ecode4 = 0 ;
	unsigned char temp5 ;
	unsigned char val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:UCharUCharAbsArrayProjector_process",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_unsigned_char_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharUCharAbsArrayProjector_process" "', argument " "1"" of type '" "npstat::AbsArrayProjector< unsigned char,unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< unsigned char,unsigned char > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UCharUCharAbsArrayProjector_process" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UCharUCharAbsArrayProjector_process" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UCharUCharAbsArrayProjector_process" "', argument " "4"" of type '" "unsigned long""'");
	}
	arg4 = static_cast< unsigned long >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "UCharUCharAbsArrayProjector_process" "', argument " "5"" of type '" "unsigned char""'");
	}
	temp5 = static_cast< unsigned char >(val5);
	arg5 = &temp5;
	{
	try {
	(arg1)->process((unsigned int const )arg2,arg3,arg4,(unsigned char const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharUCharAbsArrayProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< unsigned char,unsigned char > arg1 = (npstat::AbsArrayProjector< unsigned char,unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned char result;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharUCharAbsArrayProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_unsigned_char_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharUCharAbsArrayProjector_result" "', argument " "1"" of type '" "npstat::AbsArrayProjector< unsigned char,unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< unsigned char,unsigned char > * >(argp1);
	{
	try {
	result = (unsigned char)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject UCharUCharAbsArrayProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsArrayProjectorT_unsigned_char_unsigned_char_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_FloatDoubleAbsArrayProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< float,double > arg1 = (npstat::AbsArrayProjector< float,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatDoubleAbsArrayProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_float_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatDoubleAbsArrayProjector" "', argument " "1"" of type '" "npstat::AbsArrayProjector< float,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< float,double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDoubleAbsArrayProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< float,double > arg1 = (npstat::AbsArrayProjector< float,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatDoubleAbsArrayProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_float_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDoubleAbsArrayProjector_clear" "', argument " "1"" of type '" "npstat::AbsArrayProjector< float,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< float,double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDoubleAbsArrayProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< float,double > arg1 = (npstat::AbsArrayProjector< float,double > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	unsigned long arg4 ;
	float *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned long val4 ;
	int ecode4 = 0 ;
	float temp5 ;
	float val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:FloatDoubleAbsArrayProjector_process",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_float_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDoubleAbsArrayProjector_process" "', argument " "1"" of type '" "npstat::AbsArrayProjector< float,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< float,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatDoubleAbsArrayProjector_process" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatDoubleAbsArrayProjector_process" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FloatDoubleAbsArrayProjector_process" "', argument " "4"" of type '" "unsigned long""'");
	}
	arg4 = static_cast< unsigned long >(val4);
	ecode5 = SWIG_AsVal_float(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FloatDoubleAbsArrayProjector_process" "', argument " "5"" of type '" "float""'");
	}
	temp5 = static_cast< float >(val5);
	arg5 = &temp5;
	{
	try {
	(arg1)->process((unsigned int const )arg2,arg3,arg4,(float const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatDoubleAbsArrayProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< float,double > arg1 = (npstat::AbsArrayProjector< float,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatDoubleAbsArrayProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_float_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatDoubleAbsArrayProjector_result" "', argument " "1"" of type '" "npstat::AbsArrayProjector< float,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< float,double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatDoubleAbsArrayProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsArrayProjectorT_float_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_IntDoubleAbsArrayProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< int,double > arg1 = (npstat::AbsArrayProjector< int,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_IntDoubleAbsArrayProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_int_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntDoubleAbsArrayProjector" "', argument " "1"" of type '" "npstat::AbsArrayProjector< int,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< int,double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntDoubleAbsArrayProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< int,double > arg1 = (npstat::AbsArrayProjector< int,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:IntDoubleAbsArrayProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_int_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntDoubleAbsArrayProjector_clear" "', argument " "1"" of type '" "npstat::AbsArrayProjector< int,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< int,double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntDoubleAbsArrayProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< int,double > arg1 = (npstat::AbsArrayProjector< int,double > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	unsigned long arg4 ;
	int *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned long val4 ;
	int ecode4 = 0 ;
	int temp5 ;
	int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:IntDoubleAbsArrayProjector_process",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_int_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntDoubleAbsArrayProjector_process" "', argument " "1"" of type '" "npstat::AbsArrayProjector< int,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< int,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntDoubleAbsArrayProjector_process" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntDoubleAbsArrayProjector_process" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IntDoubleAbsArrayProjector_process" "', argument " "4"" of type '" "unsigned long""'");
	}
	arg4 = static_cast< unsigned long >(val4);
	ecode5 = SWIG_AsVal_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IntDoubleAbsArrayProjector_process" "', argument " "5"" of type '" "int""'");
	}
	temp5 = static_cast< int >(val5);
	arg5 = &temp5;
	{
	try {
	(arg1)->process((unsigned int const )arg2,arg3,arg4,(int const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntDoubleAbsArrayProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< int,double > arg1 = (npstat::AbsArrayProjector< int,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:IntDoubleAbsArrayProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_int_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntDoubleAbsArrayProjector_result" "', argument " "1"" of type '" "npstat::AbsArrayProjector< int,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< int,double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject IntDoubleAbsArrayProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsArrayProjectorT_int_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_LLongDoubleAbsArrayProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< long long,double > arg1 = (npstat::AbsArrayProjector< long long,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LLongDoubleAbsArrayProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_long_long_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LLongDoubleAbsArrayProjector" "', argument " "1"" of type '" "npstat::AbsArrayProjector< long long,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< long long,double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongDoubleAbsArrayProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< long long,double > arg1 = (npstat::AbsArrayProjector< long long,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongDoubleAbsArrayProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_long_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongDoubleAbsArrayProjector_clear" "', argument " "1"" of type '" "npstat::AbsArrayProjector< long long,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< long long,double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongDoubleAbsArrayProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< long long,double > arg1 = (npstat::AbsArrayProjector< long long,double > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	unsigned long arg4 ;
	long long *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned long val4 ;
	int ecode4 = 0 ;
	long long temp5 ;
	long long val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:LLongDoubleAbsArrayProjector_process",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_long_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongDoubleAbsArrayProjector_process" "', argument " "1"" of type '" "npstat::AbsArrayProjector< long long,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< long long,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LLongDoubleAbsArrayProjector_process" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LLongDoubleAbsArrayProjector_process" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "LLongDoubleAbsArrayProjector_process" "', argument " "4"" of type '" "unsigned long""'");
	}
	arg4 = static_cast< unsigned long >(val4);
	ecode5 = SWIG_AsVal_long_SS_long(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "LLongDoubleAbsArrayProjector_process" "', argument " "5"" of type '" "long long""'");
	}
	temp5 = static_cast< long long >(val5);
	arg5 = &temp5;
	{
	try {
	(arg1)->process((unsigned int const )arg2,arg3,arg4,(long long const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongDoubleAbsArrayProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< long long,double > arg1 = (npstat::AbsArrayProjector< long long,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongDoubleAbsArrayProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_long_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongDoubleAbsArrayProjector_result" "', argument " "1"" of type '" "npstat::AbsArrayProjector< long long,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< long long,double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject LLongDoubleAbsArrayProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsArrayProjectorT_long_long_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_delete_UCharDoubleAbsArrayProjector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< unsigned char,double > arg1 = (npstat::AbsArrayProjector< unsigned char,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_UCharDoubleAbsArrayProjector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_unsigned_char_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UCharDoubleAbsArrayProjector" "', argument " "1"" of type '" "npstat::AbsArrayProjector< unsigned char,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< unsigned char,double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharDoubleAbsArrayProjector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< unsigned char,double > arg1 = (npstat::AbsArrayProjector< unsigned char,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharDoubleAbsArrayProjector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_unsigned_char_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharDoubleAbsArrayProjector_clear" "', argument " "1"" of type '" "npstat::AbsArrayProjector< unsigned char,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< unsigned char,double > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharDoubleAbsArrayProjector_process(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< unsigned char,double > arg1 = (npstat::AbsArrayProjector< unsigned char,double > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	unsigned long arg4 ;
	unsigned char *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned long val4 ;
	int ecode4 = 0 ;
	unsigned char temp5 ;
	unsigned char val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:UCharDoubleAbsArrayProjector_process",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_unsigned_char_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharDoubleAbsArrayProjector_process" "', argument " "1"" of type '" "npstat::AbsArrayProjector< unsigned char,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< unsigned char,double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UCharDoubleAbsArrayProjector_process" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UCharDoubleAbsArrayProjector_process" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UCharDoubleAbsArrayProjector_process" "', argument " "4"" of type '" "unsigned long""'");
	}
	arg4 = static_cast< unsigned long >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "UCharDoubleAbsArrayProjector_process" "', argument " "5"" of type '" "unsigned char""'");
	}
	temp5 = static_cast< unsigned char >(val5);
	arg5 = &temp5;
	{
	try {
	(arg1)->process((unsigned int const )arg2,arg3,arg4,(unsigned char const &)arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharDoubleAbsArrayProjector_result(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsArrayProjector< unsigned char,double > arg1 = (npstat::AbsArrayProjector< unsigned char,double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharDoubleAbsArrayProjector_result",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__AbsArrayProjectorT_unsigned_char_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharDoubleAbsArrayProjector_result" "', argument " "1"" of type '" "npstat::AbsArrayProjector< unsigned char,double > *""'");
	}
	arg1 = reinterpret_cast< npstat::AbsArrayProjector< unsigned char,double > * >(argp1);
	{
	try {
	result = (double)(arg1)->result();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject UCharDoubleAbsArrayProjector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__AbsArrayProjectorT_unsigned_char_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ExpMapper1d__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ExpMapper1d *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_ExpMapper1d")) SWIG_fail;
	{
	try {
	result = (npstat::ExpMapper1d *)new npstat::ExpMapper1d();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ExpMapper1d, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ExpMapper1d__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	npstat::ExpMapper1d *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_ExpMapper1d",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExpMapper1d" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExpMapper1d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ExpMapper1d" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ExpMapper1d" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	result = (npstat::ExpMapper1d *)new npstat::ExpMapper1d(arg1,arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ExpMapper1d, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ExpMapper1d__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::ExpMapper1d *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_ExpMapper1d",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExpMapper1d" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ExpMapper1d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (npstat::ExpMapper1d *)new npstat::ExpMapper1d(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ExpMapper1d, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ExpMapper1d(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 0) {
	return _wrap_new_ExpMapper1d__SWIG_0(self, args);
	}
	if (argc == 2) {
	int _v;
	{
	int res = SWIG_AsVal_double(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ExpMapper1d__SWIG_2(self, args);
	}
	}
	}
	if (argc == 4) {
	int _v;
	{
	int res = SWIG_AsVal_double(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ExpMapper1d__SWIG_1(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExpMapper1d'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ExpMapper1d::ExpMapper1d()\n"
	" npstat::ExpMapper1d::ExpMapper1d(double const,double const,double const,double const)\n"
	" npstat::ExpMapper1d::ExpMapper1d(double const,double const)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1d___call__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ExpMapper1d arg1 = (npstat::ExpMapper1d ) 0 ;
	double *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double temp2 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:ExpMapper1d___call__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ExpMapper1d, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1d___call__" "', argument " "1"" of type '" "npstat::ExpMapper1d const *""'");
	}
	arg1 = reinterpret_cast< npstat::ExpMapper1d * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExpMapper1d___call__" "', argument " "2"" of type '" "double""'");
	}
	temp2 = static_cast< double >(val2);
	arg2 = &temp2;
	{
	try {
	result = (double)((npstat::ExpMapper1d const )arg1)->operator ()((double const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1d_a(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ExpMapper1d arg1 = (npstat::ExpMapper1d ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1d_a",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ExpMapper1d, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1d_a" "', argument " "1"" of type '" "npstat::ExpMapper1d const *""'");
	}
	arg1 = reinterpret_cast< npstat::ExpMapper1d * >(argp1);
	{
	try {
	result = (double)((npstat::ExpMapper1d const *)arg1)->a();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1d_b(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ExpMapper1d arg1 = (npstat::ExpMapper1d ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1d_b",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ExpMapper1d, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1d_b" "', argument " "1"" of type '" "npstat::ExpMapper1d const *""'");
	}
	arg1 = reinterpret_cast< npstat::ExpMapper1d * >(argp1);
	{
	try {
	result = (double)((npstat::ExpMapper1d const *)arg1)->b();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ExpMapper1d(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ExpMapper1d arg1 = (npstat::ExpMapper1d ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ExpMapper1d",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ExpMapper1d, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExpMapper1d" "', argument " "1"" of type '" "npstat::ExpMapper1d *""'");
	}
	arg1 = reinterpret_cast< npstat::ExpMapper1d * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ExpMapper1d_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ExpMapper1d, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_ExpMapper1dVector_iterator(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	PyObject arg2 = (PyObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	swig::SwigPyIterator *result = 0 ;

	arg2 = &obj0;
	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1dVector_iterator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_iterator" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	result = (swig::SwigPyIterator *)std_vector_Sl_npstat_ExpMapper1d_Sg__iterator(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___nonzero__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1dVector___nonzero__",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector___nonzero__" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	result = (bool)std_vector_Sl_npstat_ExpMapper1d_Sg____nonzero__((std::vector< npstat::ExpMapper1d > const *)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___bool__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1dVector___bool__",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector___bool__" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	result = (bool)std_vector_Sl_npstat_ExpMapper1d_Sg____bool__((std::vector< npstat::ExpMapper1d > const *)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___len__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::ExpMapper1d >::size_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1dVector___len__",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector___len__" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	result = std_vector_Sl_npstat_ExpMapper1d_Sg____len__((std::vector< npstat::ExpMapper1d > const *)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___getslice__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d >::difference_type arg2 ;
	std::vector< npstat::ExpMapper1d >::difference_type arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ExpMapper1dVector___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector___getslice__" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExpMapper1dVector___getslice__" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::ExpMapper1d >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ExpMapper1dVector___getslice__" "', argument " "3"" of type '" "std::vector< npstat::ExpMapper1d >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::ExpMapper1d >::difference_type >(val3);
	{
	try {
	try {
	result = (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > *)std_vector_Sl_npstat_ExpMapper1d_Sg____getslice__(arg1,arg2,arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___setslice____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d >::difference_type arg2 ;
	std::vector< npstat::ExpMapper1d >::difference_type arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ExpMapper1dVector___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector___setslice__" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExpMapper1dVector___setslice__" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::ExpMapper1d >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ExpMapper1dVector___setslice__" "', argument " "3"" of type '" "std::vector< npstat::ExpMapper1d >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::ExpMapper1d >::difference_type >(val3);
	{
	try {
	try {
	std_vector_Sl_npstat_ExpMapper1d_Sg____setslice____SWIG_0(arg1,arg2,arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___setslice____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d >::difference_type arg2 ;
	std::vector< npstat::ExpMapper1d >::difference_type arg3 ;
	std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	int res4 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:ExpMapper1dVector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector___setslice__" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExpMapper1dVector___setslice__" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::ExpMapper1d >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ExpMapper1dVector___setslice__" "', argument " "3"" of type '" "std::vector< npstat::ExpMapper1d >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::ExpMapper1d >::difference_type >(val3);
	{
	std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > ptr = (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > )0;
	res4 = swig::asptr(obj3, &ptr);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ExpMapper1dVector___setslice__" "', argument " "4"" of type '" "std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExpMapper1dVector___setslice__" "', argument " "4"" of type '" "std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > const &""'");
	}
	arg4 = ptr;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_ExpMapper1d_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > const &)*arg4);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (SWIG_IsNewObj(res4)) delete arg4;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res4)) delete arg4;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___setslice__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ExpMapper1dVector___setslice____SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[3], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ExpMapper1dVector___setslice____SWIG_1(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ExpMapper1dVector___setslice__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::ExpMapper1d >::__setslice__(std::vector< npstat::ExpMapper1d >::difference_type,std::vector< npstat::ExpMapper1d >::difference_type)\n"
	" std::vector< npstat::ExpMapper1d >::__setslice__(std::vector< npstat::ExpMapper1d >::difference_type,std::vector< npstat::ExpMapper1d >::difference_type,std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___delslice__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d >::difference_type arg2 ;
	std::vector< npstat::ExpMapper1d >::difference_type arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	ptrdiff_t val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ExpMapper1dVector___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector___delslice__" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExpMapper1dVector___delslice__" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::ExpMapper1d >::difference_type >(val2);
	ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ExpMapper1dVector___delslice__" "', argument " "3"" of type '" "std::vector< npstat::ExpMapper1d >::difference_type""'");
	}
	arg3 = static_cast< std::vector< npstat::ExpMapper1d >::difference_type >(val3);
	{
	try {
	try {
	std_vector_Sl_npstat_ExpMapper1d_Sg____delslice__(arg1,arg2,arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___delitem____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d >::difference_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:ExpMapper1dVector___delitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector___delitem__" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExpMapper1dVector___delitem__" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::ExpMapper1d >::difference_type >(val2);
	{
	try {
	try {
	std_vector_Sl_npstat_ExpMapper1d_Sg____delitem____SWIG_0(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___getitem____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:ExpMapper1dVector___getitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector___getitem__" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ExpMapper1dVector___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	try {
	try {
	result = (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > *)std_vector_Sl_npstat_ExpMapper1d_Sg____getitem____SWIG_0(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___setitem____SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res3 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ExpMapper1dVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector___setitem__" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ExpMapper1dVector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > ptr = (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > )0;
	res3 = swig::asptr(obj2, &ptr);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExpMapper1dVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExpMapper1dVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > const &""'");
	}
	arg3 = ptr;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_ExpMapper1d_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > const &)*arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (SWIG_IsNewObj(res3)) delete arg3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res3)) delete arg3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___setitem____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:ExpMapper1dVector___setitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector___setitem__" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ExpMapper1dVector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_ExpMapper1d_Sg____setitem____SWIG_1(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___delitem____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	PySliceObject arg2 = (PySliceObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:ExpMapper1dVector___delitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector___delitem__" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	if (!PySlice_Check(obj1)) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ExpMapper1dVector___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
	}
	arg2 = (PySliceObject *) obj1;
	}
	{
	try {
	try {
	std_vector_Sl_npstat_ExpMapper1d_Sg____delitem____SWIG_1(arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}
	catch(std::invalid_argument &_e) {
	SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___delitem__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	return _wrap_ExpMapper1dVector___delitem____SWIG_1(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ExpMapper1dVector___delitem____SWIG_0(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ExpMapper1dVector___delitem__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::ExpMapper1d >::__delitem__(std::vector< npstat::ExpMapper1d >::difference_type)\n"
	" std::vector< npstat::ExpMapper1d >::__delitem__(PySliceObject *)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___getitem____SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d >::difference_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::ExpMapper1d >::value_type *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:ExpMapper1dVector___getitem__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector___getitem__" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExpMapper1dVector___getitem__" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::ExpMapper1d >::difference_type >(val2);
	{
	try {
	try {
	result = (std::vector< npstat::ExpMapper1d >::value_type ) &std_vector_Sl_npstat_ExpMapper1d_Sg____getitem____SWIG_1((std::vector< npstat::ExpMapper1d > const )arg1,arg2);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ExpMapper1d, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___getitem__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	return _wrap_ExpMapper1dVector___getitem____SWIG_0(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ExpMapper1dVector___getitem____SWIG_1(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ExpMapper1dVector___getitem__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::ExpMapper1d >::__getitem__(PySliceObject *)\n"
	" std::vector< npstat::ExpMapper1d >::__getitem__(std::vector< npstat::ExpMapper1d >::difference_type) const\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___setitem____SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d >::difference_type arg2 ;
	std::vector< npstat::ExpMapper1d >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	ptrdiff_t val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ExpMapper1dVector___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector___setitem__" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExpMapper1dVector___setitem__" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::difference_type""'");
	}
	arg2 = static_cast< std::vector< npstat::ExpMapper1d >::difference_type >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__ExpMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExpMapper1dVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::ExpMapper1d >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExpMapper1dVector___setitem__" "', argument " "3"" of type '" "std::vector< npstat::ExpMapper1d >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::ExpMapper1d >::value_type * >(argp3);
	{
	try {
	try {
	std_vector_Sl_npstat_ExpMapper1d_Sg____setitem____SWIG_2(arg1,arg2,(npstat::ExpMapper1d const &)*arg3);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector___setitem__(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	return _wrap_ExpMapper1dVector___setitem____SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	_v = PySlice_Check(argv[1]);
	}
	if (_v) {
	int res = swig::asptr(argv[2], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ExpMapper1dVector___setitem____SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__ExpMapper1d, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ExpMapper1dVector___setitem____SWIG_2(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ExpMapper1dVector___setitem__'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::ExpMapper1d >::__setitem__(PySliceObject *,std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > const &)\n"
	" std::vector< npstat::ExpMapper1d >::__setitem__(PySliceObject *)\n"
	" std::vector< npstat::ExpMapper1d >::__setitem__(std::vector< npstat::ExpMapper1d >::difference_type,std::vector< npstat::ExpMapper1d >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_pop(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::ExpMapper1d >::value_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1dVector_pop",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_pop" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	try {
	result = std_vector_Sl_npstat_ExpMapper1d_Sg__pop(arg1);
	}
	catch(std::out_of_range &_e) {
	SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
	}

	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new std::vector< npstat::ExpMapper1d >::value_type(static_cast< const std::vector< npstat::ExpMapper1d >::value_type& >(result))), SWIGTYPE_p_npstat__ExpMapper1d, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_append(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d >::value_type *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:ExpMapper1dVector_append",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_append" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__ExpMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExpMapper1dVector_append" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::value_type const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExpMapper1dVector_append" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::value_type const &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::ExpMapper1d >::value_type * >(argp2);
	{
	try {
	std_vector_Sl_npstat_ExpMapper1d_Sg__append(arg1,(npstat::ExpMapper1d const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ExpMapper1dVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_ExpMapper1dVector")) SWIG_fail;
	{
	try {
	result = (std::vector< npstat::ExpMapper1d > *)new std::vector< npstat::ExpMapper1d >();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ExpMapper1dVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > *arg1 = 0 ;
	int res1 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::ExpMapper1d > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_ExpMapper1dVector",&obj0)) SWIG_fail;
	{
	std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > ptr = (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExpMapper1dVector" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExpMapper1dVector" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > const &""'");
	}
	arg1 = ptr;
	}
	{
	try {
	result = (std::vector< npstat::ExpMapper1d > )new std::vector< npstat::ExpMapper1d >((std::vector< npstat::ExpMapper1d > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_empty(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1dVector_empty",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_empty" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	result = (bool)((std::vector< npstat::ExpMapper1d > const *)arg1)->empty();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_size(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::ExpMapper1d >::size_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1dVector_size",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_size" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	result = ((std::vector< npstat::ExpMapper1d > const *)arg1)->size();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_swap(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:ExpMapper1dVector_swap",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_swap" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExpMapper1dVector_swap" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d > &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExpMapper1dVector_swap" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d > &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp2);
	{
	try {
	(arg1)->swap(*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_begin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::ExpMapper1d >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1dVector_begin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_begin" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	result = (arg1)->begin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::ExpMapper1d >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_end(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::ExpMapper1d >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1dVector_end",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_end" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	result = (arg1)->end();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::ExpMapper1d >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_rbegin(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::ExpMapper1d >::reverse_iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1dVector_rbegin",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_rbegin" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	result = (arg1)->rbegin();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::ExpMapper1d >::reverse_iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_rend(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::ExpMapper1d >::reverse_iterator result;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1dVector_rend",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_rend" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	result = (arg1)->rend();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::ExpMapper1d >::reverse_iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_clear(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1dVector_clear",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_clear" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	(arg1)->clear();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_get_allocator(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< std::allocator< npstat::ExpMapper1d > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1dVector_get_allocator",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_get_allocator" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	result = ((std::vector< npstat::ExpMapper1d > const *)arg1)->get_allocator();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new std::vector< npstat::ExpMapper1d >::allocator_type(static_cast< const std::vector< npstat::ExpMapper1d >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_npstat__ExpMapper1d_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ExpMapper1dVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d >::size_type arg1 ;
	size_t val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::ExpMapper1d > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_ExpMapper1dVector",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_size_t(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExpMapper1dVector" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d >::size_type""'");
	}
	arg1 = static_cast< std::vector< npstat::ExpMapper1d >::size_type >(val1);
	{
	try {
	result = (std::vector< npstat::ExpMapper1d > *)new std::vector< npstat::ExpMapper1d >(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_pop_back(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1dVector_pop_back",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_pop_back" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	(arg1)->pop_back();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_resize__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d >::size_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:ExpMapper1dVector_resize",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_resize" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExpMapper1dVector_resize" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::ExpMapper1d >::size_type >(val2);
	{
	try {
	(arg1)->resize(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_erase__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d >::iterator arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::ExpMapper1d >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"OO:ExpMapper1dVector_erase",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_erase" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ExpMapper1dVector_erase" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::ExpMapper1d >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::ExpMapper1d >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ExpMapper1dVector_erase" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::iterator""'");
	}
	}
	{
	try {
	result = std_vector_Sl_npstat_ExpMapper1d_Sg__erase__SWIG_0(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::ExpMapper1d >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_erase__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d >::iterator arg2 ;
	std::vector< npstat::ExpMapper1d >::iterator arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	swig::SwigPyIterator *iter3 = 0 ;
	int res3 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	std::vector< npstat::ExpMapper1d >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ExpMapper1dVector_erase",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_erase" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ExpMapper1dVector_erase" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::ExpMapper1d >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::ExpMapper1d >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ExpMapper1dVector_erase" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::iterator""'");
	}
	}
	res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res3) \|\| !iter3) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ExpMapper1dVector_erase" "', argument " "3"" of type '" "std::vector< npstat::ExpMapper1d >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::ExpMapper1d >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::ExpMapper1d >::iterator > >(iter3);
	if (iter_t) {
	arg3 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ExpMapper1dVector_erase" "', argument " "3"" of type '" "std::vector< npstat::ExpMapper1d >::iterator""'");
	}
	}
	{
	try {
	result = std_vector_Sl_npstat_ExpMapper1d_Sg__erase__SWIG_1(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::ExpMapper1d >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_erase(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::ExpMapper1d >::iterator > *>(iter) != 0));
	if (_v) {
	return _wrap_ExpMapper1dVector_erase__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::ExpMapper1d >::iterator > *>(iter) != 0));
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::ExpMapper1d >::iterator > *>(iter) != 0));
	if (_v) {
	return _wrap_ExpMapper1dVector_erase__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ExpMapper1dVector_erase'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::ExpMapper1d >::erase(std::vector< npstat::ExpMapper1d >::iterator)\n"
	" std::vector< npstat::ExpMapper1d >::erase(std::vector< npstat::ExpMapper1d >::iterator,std::vector< npstat::ExpMapper1d >::iterator)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_new_ExpMapper1dVector__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d >::size_type arg1 ;
	std::vector< npstat::ExpMapper1d >::value_type *arg2 = 0 ;
	size_t val1 ;
	int ecode1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< npstat::ExpMapper1d > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_ExpMapper1dVector",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_size_t(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ExpMapper1dVector" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d >::size_type""'");
	}
	arg1 = static_cast< std::vector< npstat::ExpMapper1d >::size_type >(val1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__ExpMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ExpMapper1dVector" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::value_type const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ExpMapper1dVector" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::value_type const &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::ExpMapper1d >::value_type * >(argp2);
	{
	try {
	result = (std::vector< npstat::ExpMapper1d > )new std::vector< npstat::ExpMapper1d >(arg1,(std::vector< npstat::ExpMapper1d >::value_type const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ExpMapper1dVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 0) {
	return _wrap_new_ExpMapper1dVector__SWIG_0(self, args);
	}
	if (argc == 1) {
	int _v;
	{
	int res = SWIG_AsVal_size_t(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ExpMapper1dVector__SWIG_2(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_ExpMapper1dVector__SWIG_1(self, args);
	}
	}
	if (argc == 2) {
	int _v;
	{
	int res = SWIG_AsVal_size_t(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__ExpMapper1d, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_ExpMapper1dVector__SWIG_3(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ExpMapper1dVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::ExpMapper1d >::vector()\n"
	" std::vector< npstat::ExpMapper1d >::vector(std::vector< npstat::ExpMapper1d > const &)\n"
	" std::vector< npstat::ExpMapper1d >::vector(std::vector< npstat::ExpMapper1d >::size_type)\n"
	" std::vector< npstat::ExpMapper1d >::vector(std::vector< npstat::ExpMapper1d >::size_type,std::vector< npstat::ExpMapper1d >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_push_back(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d >::value_type *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:ExpMapper1dVector_push_back",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_push_back" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__ExpMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExpMapper1dVector_push_back" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::value_type const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExpMapper1dVector_push_back" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::value_type const &""'");
	}
	arg2 = reinterpret_cast< std::vector< npstat::ExpMapper1d >::value_type * >(argp2);
	{
	try {
	(arg1)->push_back((std::vector< npstat::ExpMapper1d >::value_type const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_front(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::ExpMapper1d >::value_type *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1dVector_front",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_front" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	result = (std::vector< npstat::ExpMapper1d >::value_type ) &((std::vector< npstat::ExpMapper1d > const )arg1)->front();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ExpMapper1d, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_back(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::ExpMapper1d >::value_type *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1dVector_back",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_back" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	result = (std::vector< npstat::ExpMapper1d >::value_type ) &((std::vector< npstat::ExpMapper1d > const )arg1)->back();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ExpMapper1d, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_assign(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d >::size_type arg2 ;
	std::vector< npstat::ExpMapper1d >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ExpMapper1dVector_assign",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_assign" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExpMapper1dVector_assign" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::ExpMapper1d >::size_type >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__ExpMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExpMapper1dVector_assign" "', argument " "3"" of type '" "std::vector< npstat::ExpMapper1d >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExpMapper1dVector_assign" "', argument " "3"" of type '" "std::vector< npstat::ExpMapper1d >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::ExpMapper1d >::value_type * >(argp3);
	{
	try {
	(arg1)->assign(arg2,(std::vector< npstat::ExpMapper1d >::value_type const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_resize__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d >::size_type arg2 ;
	std::vector< npstat::ExpMapper1d >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ExpMapper1dVector_resize",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_resize" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExpMapper1dVector_resize" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::ExpMapper1d >::size_type >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__ExpMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExpMapper1dVector_resize" "', argument " "3"" of type '" "std::vector< npstat::ExpMapper1d >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExpMapper1dVector_resize" "', argument " "3"" of type '" "std::vector< npstat::ExpMapper1d >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::ExpMapper1d >::value_type * >(argp3);
	{
	try {
	(arg1)->resize(arg2,(std::vector< npstat::ExpMapper1d >::value_type const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_resize(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_size_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ExpMapper1dVector_resize__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_size_t(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__ExpMapper1d, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ExpMapper1dVector_resize__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ExpMapper1dVector_resize'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::ExpMapper1d >::resize(std::vector< npstat::ExpMapper1d >::size_type)\n"
	" std::vector< npstat::ExpMapper1d >::resize(std::vector< npstat::ExpMapper1d >::size_type,std::vector< npstat::ExpMapper1d >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_insert__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d >::iterator arg2 ;
	std::vector< npstat::ExpMapper1d >::value_type *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	std::vector< npstat::ExpMapper1d >::iterator result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ExpMapper1dVector_insert",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_insert" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ExpMapper1dVector_insert" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::ExpMapper1d >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::ExpMapper1d >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ExpMapper1dVector_insert" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::iterator""'");
	}
	}
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_npstat__ExpMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExpMapper1dVector_insert" "', argument " "3"" of type '" "std::vector< npstat::ExpMapper1d >::value_type const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExpMapper1dVector_insert" "', argument " "3"" of type '" "std::vector< npstat::ExpMapper1d >::value_type const &""'");
	}
	arg3 = reinterpret_cast< std::vector< npstat::ExpMapper1d >::value_type * >(argp3);
	{
	try {
	result = std_vector_Sl_npstat_ExpMapper1d_Sg__insert__SWIG_0(arg1,arg2,(npstat::ExpMapper1d const &)*arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< npstat::ExpMapper1d >::iterator & >(result)),
	swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_insert__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d >::iterator arg2 ;
	std::vector< npstat::ExpMapper1d >::size_type arg3 ;
	std::vector< npstat::ExpMapper1d >::value_type *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	swig::SwigPyIterator *iter2 = 0 ;
	int res2 ;
	size_t val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:ExpMapper1dVector_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_insert" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
	if (!SWIG_IsOK(res2) \|\| !iter2) {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ExpMapper1dVector_insert" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::iterator""'");
	} else {
	swig::SwigPyIterator_T<std::vector< npstat::ExpMapper1d >::iterator > iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::ExpMapper1d >::iterator > >(iter2);
	if (iter_t) {
	arg2 = iter_t->get_current();
	} else {
	SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ExpMapper1dVector_insert" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::iterator""'");
	}
	}
	ecode3 = SWIG_AsVal_size_t(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ExpMapper1dVector_insert" "', argument " "3"" of type '" "std::vector< npstat::ExpMapper1d >::size_type""'");
	}
	arg3 = static_cast< std::vector< npstat::ExpMapper1d >::size_type >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__ExpMapper1d, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ExpMapper1dVector_insert" "', argument " "4"" of type '" "std::vector< npstat::ExpMapper1d >::value_type const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExpMapper1dVector_insert" "', argument " "4"" of type '" "std::vector< npstat::ExpMapper1d >::value_type const &""'");
	}
	arg4 = reinterpret_cast< std::vector< npstat::ExpMapper1d >::value_type * >(argp4);
	{
	try {
	std_vector_Sl_npstat_ExpMapper1d_Sg__insert__SWIG_1(arg1,arg2,arg3,(npstat::ExpMapper1d const &)*arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_insert(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::ExpMapper1d >::iterator > *>(iter) != 0));
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_npstat__ExpMapper1d, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ExpMapper1dVector_insert__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = swig::asptr(argv[0], (std::vector< npstat::ExpMapper1d,std::allocator< npstat::ExpMapper1d > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	swig::SwigPyIterator *iter = 0;
	int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
	_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< npstat::ExpMapper1d >::iterator > *>(iter) != 0));
	if (_v) {
	{
	int res = SWIG_AsVal_size_t(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__ExpMapper1d, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_ExpMapper1dVector_insert__SWIG_1(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ExpMapper1dVector_insert'.\n"
	" Possible C/C++ prototypes are:\n"
	" std::vector< npstat::ExpMapper1d >::insert(std::vector< npstat::ExpMapper1d >::iterator,std::vector< npstat::ExpMapper1d >::value_type const &)\n"
	" std::vector< npstat::ExpMapper1d >::insert(std::vector< npstat::ExpMapper1d >::iterator,std::vector< npstat::ExpMapper1d >::size_type,std::vector< npstat::ExpMapper1d >::value_type const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_reserve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	std::vector< npstat::ExpMapper1d >::size_type arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	size_t val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:ExpMapper1dVector_reserve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_reserve" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	ecode2 = SWIG_AsVal_size_t(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExpMapper1dVector_reserve" "', argument " "2"" of type '" "std::vector< npstat::ExpMapper1d >::size_type""'");
	}
	arg2 = static_cast< std::vector< npstat::ExpMapper1d >::size_type >(val2);
	{
	try {
	(arg1)->reserve(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ExpMapper1dVector_capacity(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< npstat::ExpMapper1d >::size_type result;

	if (!PyArg_ParseTuple(args,(char *)"O:ExpMapper1dVector_capacity",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExpMapper1dVector_capacity" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > const *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	result = ((std::vector< npstat::ExpMapper1d > const *)arg1)->capacity();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ExpMapper1dVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< npstat::ExpMapper1d > arg1 = (std::vector< npstat::ExpMapper1d > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ExpMapper1dVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExpMapper1dVector" "', argument " "1"" of type '" "std::vector< npstat::ExpMapper1d > *""'");
	}
	arg1 = reinterpret_cast< std::vector< npstat::ExpMapper1d > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ExpMapper1dVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_npstat__ExpMapper1d_std__allocatorT_npstat__ExpMapper1d_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_rescanArray__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< double,1U,10U > *arg1 = 0 ;
	npstat::ArrayND< double,1U,10U > arg2 = (npstat::ArrayND< double,1U,10U > ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:rescanArray",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rescanArray" "', argument " "1"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rescanArray" "', argument " "1"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< double,1U,10U > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rescanArray" "', argument " "2"" of type '" "npstat::ArrayND< double,1U,10U > *""'");
	}
	arg2 = reinterpret_cast< npstat::ArrayND< double,1U,10U > * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rescanArray" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR rescanArray< double,1U,10U,double,1U,10U >((npstat::ArrayND< double,1U,10U > const &)*arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_rescanArray__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< double,1U,10U > *arg1 = 0 ;
	npstat::ArrayND< double,1U,10U > arg2 = (npstat::ArrayND< double,1U,10U > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:rescanArray",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rescanArray" "', argument " "1"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rescanArray" "', argument " "1"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< double,1U,10U > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rescanArray" "', argument " "2"" of type '" "npstat::ArrayND< double,1U,10U > *""'");
	}
	arg2 = reinterpret_cast< npstat::ArrayND< double,1U,10U > * >(argp2);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR rescanArray< double,1U,10U,double,1U,10U >((npstat::ArrayND< double,1U,10U > const &)*arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_rescanArray__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< float,1U,10U > *arg1 = 0 ;
	npstat::ArrayND< float,1U,10U > arg2 = (npstat::ArrayND< float,1U,10U > ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:rescanArray",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rescanArray" "', argument " "1"" of type '" "npstat::ArrayND< float,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rescanArray" "', argument " "1"" of type '" "npstat::ArrayND< float,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< float,1U,10U > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rescanArray" "', argument " "2"" of type '" "npstat::ArrayND< float,1U,10U > *""'");
	}
	arg2 = reinterpret_cast< npstat::ArrayND< float,1U,10U > * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rescanArray" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR rescanArray< float,1U,10U,float,1U,10U >((npstat::ArrayND< float,1U,10U > const &)*arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_rescanArray__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< float,1U,10U > *arg1 = 0 ;
	npstat::ArrayND< float,1U,10U > arg2 = (npstat::ArrayND< float,1U,10U > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:rescanArray",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rescanArray" "', argument " "1"" of type '" "npstat::ArrayND< float,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rescanArray" "', argument " "1"" of type '" "npstat::ArrayND< float,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< float,1U,10U > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rescanArray" "', argument " "2"" of type '" "npstat::ArrayND< float,1U,10U > *""'");
	}
	arg2 = reinterpret_cast< npstat::ArrayND< float,1U,10U > * >(argp2);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR rescanArray< float,1U,10U,float,1U,10U >((npstat::ArrayND< float,1U,10U > const &)*arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_rescanArray(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_rescanArray__SWIG_3(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_rescanArray__SWIG_5(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_rescanArray__SWIG_4(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_rescanArray__SWIG_2(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'rescanArray'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::rescanArray< double,1U,10U,double,1U,10U >(npstat::ArrayND< double,1U,10U > const &,npstat::ArrayND< double,1U,10U > *,unsigned int)\n"
	" npstat::rescanArray< double,1U,10U,double,1U,10U >(npstat::ArrayND< double,1U,10U > const &,npstat::ArrayND< double,1U,10U > *)\n"
	" npstat::rescanArray< float,1U,10U,float,1U,10U >(npstat::ArrayND< float,1U,10U > const &,npstat::ArrayND< float,1U,10U > *,unsigned int)\n"
	" npstat::rescanArray< float,1U,10U,float,1U,10U >(npstat::ArrayND< float,1U,10U > const &,npstat::ArrayND< float,1U,10U > *)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_clearBuffer__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned char arg1 = (unsigned char ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:clearBuffer",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clearBuffer" "', argument " "1"" of type '" "unsigned char *""'");
	}
	arg1 = reinterpret_cast< unsigned char * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "clearBuffer" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR clearBuffer< unsigned char >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_clearBuffer__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int arg1 = (int ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:clearBuffer",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clearBuffer" "', argument " "1"" of type '" "int *""'");
	}
	arg1 = reinterpret_cast< int * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "clearBuffer" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR clearBuffer< int >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_clearBuffer__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	long long arg1 = (long long ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:clearBuffer",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_long_long, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clearBuffer" "', argument " "1"" of type '" "long long *""'");
	}
	arg1 = reinterpret_cast< long long * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "clearBuffer" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR clearBuffer< long long >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_clearBuffer__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	float arg1 = (float ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:clearBuffer",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clearBuffer" "', argument " "1"" of type '" "float *""'");
	}
	arg1 = reinterpret_cast< float * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "clearBuffer" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR clearBuffer< float >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_clearBuffer__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 = (double ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:clearBuffer",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clearBuffer" "', argument " "1"" of type '" "double *""'");
	}
	arg1 = reinterpret_cast< double * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "clearBuffer" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR clearBuffer< double >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_clearBuffer(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_char, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_clearBuffer__SWIG_1(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_clearBuffer__SWIG_2(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_long_long, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_clearBuffer__SWIG_3(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_clearBuffer__SWIG_4(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_clearBuffer__SWIG_5(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'clearBuffer'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::clearBuffer< unsigned char >(unsigned char *,unsigned long const)\n"
	" npstat::clearBuffer< int >(int *,unsigned long const)\n"
	" npstat::clearBuffer< long long >(long long *,unsigned long const)\n"
	" npstat::clearBuffer< float >(float *,unsigned long const)\n"
	" npstat::clearBuffer< double >(double *,unsigned long const)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned char arg1 = (unsigned char ) 0 ;
	unsigned char arg2 = (unsigned char ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "unsigned char *""'");
	}
	arg1 = reinterpret_cast< unsigned char * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "unsigned char const *""'");
	}
	arg2 = reinterpret_cast< unsigned char * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< unsigned char,unsigned char >(arg1,(unsigned char const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned char arg1 = (unsigned char ) 0 ;
	int arg2 = (int ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "unsigned char *""'");
	}
	arg1 = reinterpret_cast< unsigned char * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "int const *""'");
	}
	arg2 = reinterpret_cast< int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< unsigned char,int >(arg1,(int const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned char arg1 = (unsigned char ) 0 ;
	long long arg2 = (long long ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "unsigned char *""'");
	}
	arg1 = reinterpret_cast< unsigned char * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_long_long, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "long long const *""'");
	}
	arg2 = reinterpret_cast< long long * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< unsigned char,long long >(arg1,(long long const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned char arg1 = (unsigned char ) 0 ;
	float arg2 = (float ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "unsigned char *""'");
	}
	arg1 = reinterpret_cast< unsigned char * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "float const *""'");
	}
	arg2 = reinterpret_cast< float * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< unsigned char,float >(arg1,(float const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned char arg1 = (unsigned char ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_char, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "unsigned char *""'");
	}
	arg1 = reinterpret_cast< unsigned char * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< unsigned char,double >(arg1,(double const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int arg1 = (int ) 0 ;
	unsigned char arg2 = (unsigned char ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "int *""'");
	}
	arg1 = reinterpret_cast< int * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "unsigned char const *""'");
	}
	arg2 = reinterpret_cast< unsigned char * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< int,unsigned char >(arg1,(unsigned char const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int arg1 = (int ) 0 ;
	int arg2 = (int ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "int *""'");
	}
	arg1 = reinterpret_cast< int * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "int const *""'");
	}
	arg2 = reinterpret_cast< int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< int,int >(arg1,(int const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int arg1 = (int ) 0 ;
	long long arg2 = (long long ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "int *""'");
	}
	arg1 = reinterpret_cast< int * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_long_long, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "long long const *""'");
	}
	arg2 = reinterpret_cast< long long * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< int,long long >(arg1,(long long const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int arg1 = (int ) 0 ;
	float arg2 = (float ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "int *""'");
	}
	arg1 = reinterpret_cast< int * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "float const *""'");
	}
	arg2 = reinterpret_cast< float * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< int,float >(arg1,(float const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int arg1 = (int ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "int *""'");
	}
	arg1 = reinterpret_cast< int * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< int,double >(arg1,(double const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	long long arg1 = (long long ) 0 ;
	unsigned char arg2 = (unsigned char ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_long_long, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "long long *""'");
	}
	arg1 = reinterpret_cast< long long * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "unsigned char const *""'");
	}
	arg2 = reinterpret_cast< unsigned char * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< long long,unsigned char >(arg1,(unsigned char const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_12(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	long long arg1 = (long long ) 0 ;
	int arg2 = (int ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_long_long, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "long long *""'");
	}
	arg1 = reinterpret_cast< long long * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "int const *""'");
	}
	arg2 = reinterpret_cast< int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< long long,int >(arg1,(int const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_13(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	long long arg1 = (long long ) 0 ;
	long long arg2 = (long long ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_long_long, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "long long *""'");
	}
	arg1 = reinterpret_cast< long long * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_long_long, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "long long const *""'");
	}
	arg2 = reinterpret_cast< long long * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< long long,long long >(arg1,(long long const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_14(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	long long arg1 = (long long ) 0 ;
	float arg2 = (float ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_long_long, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "long long *""'");
	}
	arg1 = reinterpret_cast< long long * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "float const *""'");
	}
	arg2 = reinterpret_cast< float * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< long long,float >(arg1,(float const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_15(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	long long arg1 = (long long ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_long_long, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "long long *""'");
	}
	arg1 = reinterpret_cast< long long * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< long long,double >(arg1,(double const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_16(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	float arg1 = (float ) 0 ;
	unsigned char arg2 = (unsigned char ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "float *""'");
	}
	arg1 = reinterpret_cast< float * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "unsigned char const *""'");
	}
	arg2 = reinterpret_cast< unsigned char * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< float,unsigned char >(arg1,(unsigned char const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_17(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	float arg1 = (float ) 0 ;
	int arg2 = (int ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "float *""'");
	}
	arg1 = reinterpret_cast< float * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "int const *""'");
	}
	arg2 = reinterpret_cast< int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< float,int >(arg1,(int const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_18(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	float arg1 = (float ) 0 ;
	long long arg2 = (long long ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "float *""'");
	}
	arg1 = reinterpret_cast< float * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_long_long, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "long long const *""'");
	}
	arg2 = reinterpret_cast< long long * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< float,long long >(arg1,(long long const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_19(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	float arg1 = (float ) 0 ;
	float arg2 = (float ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "float *""'");
	}
	arg1 = reinterpret_cast< float * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "float const *""'");
	}
	arg2 = reinterpret_cast< float * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< float,float >(arg1,(float const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_20(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	float arg1 = (float ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "float *""'");
	}
	arg1 = reinterpret_cast< float * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< float,double >(arg1,(double const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_21(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 = (double ) 0 ;
	unsigned char arg2 = (unsigned char ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "double *""'");
	}
	arg1 = reinterpret_cast< double * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "unsigned char const *""'");
	}
	arg2 = reinterpret_cast< unsigned char * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< double,unsigned char >(arg1,(unsigned char const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_22(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 = (double ) 0 ;
	int arg2 = (int ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "double *""'");
	}
	arg1 = reinterpret_cast< double * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "int const *""'");
	}
	arg2 = reinterpret_cast< int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< double,int >(arg1,(int const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_23(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 = (double ) 0 ;
	long long arg2 = (long long ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "double *""'");
	}
	arg1 = reinterpret_cast< double * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_long_long, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "long long const *""'");
	}
	arg2 = reinterpret_cast< long long * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< double,long long >(arg1,(long long const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_24(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 = (double ) 0 ;
	float arg2 = (float ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "double *""'");
	}
	arg1 = reinterpret_cast< double * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "float const *""'");
	}
	arg2 = reinterpret_cast< float * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< double,float >(arg1,(float const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer__SWIG_25(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 = (double ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned long arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned long val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:copyBuffer",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copyBuffer" "', argument " "1"" of type '" "double *""'");
	}
	arg1 = reinterpret_cast< double * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copyBuffer" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_long(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copyBuffer" "', argument " "3"" of type '" "unsigned long""'");
	}
	arg3 = static_cast< unsigned long >(val3);
	{
	try {
	npstat::SWIGTEMPLATEDISAMBIGUATOR copyBuffer< double,double >(arg1,(double const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_copyBuffer(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_char, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_1(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_char, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_char, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_long_long, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_char, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_4(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_char, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_5(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_6(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_7(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_long_long, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_8(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_9(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_10(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_long_long, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_11(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_long_long, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_12(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_long_long, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_long_long, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_13(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_long_long, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_14(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_long_long, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_15(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_16(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_17(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_long_long, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_18(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_19(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_20(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_21(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_22(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_long_long, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_23(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_24(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_copyBuffer__SWIG_25(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'copyBuffer'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::copyBuffer< unsigned char,unsigned char >(unsigned char ,unsigned char const ,unsigned long const)\n"
	" npstat::copyBuffer< unsigned char,int >(unsigned char ,int const ,unsigned long const)\n"
	" npstat::copyBuffer< unsigned char,long long >(unsigned char ,long long const ,unsigned long const)\n"
	" npstat::copyBuffer< unsigned char,float >(unsigned char ,float const ,unsigned long const)\n"
	" npstat::copyBuffer< unsigned char,double >(unsigned char ,double const ,unsigned long const)\n"
	" npstat::copyBuffer< int,unsigned char >(int ,unsigned char const ,unsigned long const)\n"
	" npstat::copyBuffer< int,int >(int ,int const ,unsigned long const)\n"
	" npstat::copyBuffer< int,long long >(int ,long long const ,unsigned long const)\n"
	" npstat::copyBuffer< int,float >(int ,float const ,unsigned long const)\n"
	" npstat::copyBuffer< int,double >(int ,double const ,unsigned long const)\n"
	" npstat::copyBuffer< long long,unsigned char >(long long ,unsigned char const ,unsigned long const)\n"
	" npstat::copyBuffer< long long,int >(long long ,int const ,unsigned long const)\n"
	" npstat::copyBuffer< long long,long long >(long long ,long long const ,unsigned long const)\n"
	" npstat::copyBuffer< long long,float >(long long ,float const ,unsigned long const)\n"
	" npstat::copyBuffer< long long,double >(long long ,double const ,unsigned long const)\n"
	" npstat::copyBuffer< float,unsigned char >(float ,unsigned char const ,unsigned long const)\n"
	" npstat::copyBuffer< float,int >(float ,int const ,unsigned long const)\n"
	" npstat::copyBuffer< float,long long >(float ,long long const ,unsigned long const)\n"
	" npstat::copyBuffer< float,float >(float ,float const ,unsigned long const)\n"
	" npstat::copyBuffer< float,double >(float ,double const ,unsigned long const)\n"
	" npstat::copyBuffer< double,unsigned char >(double ,unsigned char const ,unsigned long const)\n"
	" npstat::copyBuffer< double,int >(double ,int const ,unsigned long const)\n"
	" npstat::copyBuffer< double,long long >(double ,long long const ,unsigned long const)\n"
	" npstat::copyBuffer< double,float >(double ,float const ,unsigned long const)\n"
	" npstat::copyBuffer< double,double >(double ,double const ,unsigned long const)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_new_ConvolutionEngine1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int arg2 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::ConvolutionEngine1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_ConvolutionEngine1D",&obj0,&obj1)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConvolutionEngine1D" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvolutionEngine1D" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (npstat::ConvolutionEngine1D *)new npstat::ConvolutionEngine1D(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConvolutionEngine1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConvolutionEngine1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ConvolutionEngine1D *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_ConvolutionEngine1D",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConvolutionEngine1D" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	{
	try {
	result = (npstat::ConvolutionEngine1D *)new npstat::ConvolutionEngine1D(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConvolutionEngine1D, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConvolutionEngine1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConvolutionEngine1D__SWIG_1(self, args);
	}
	}
	if (argc == 2) {
	int _v;
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConvolutionEngine1D__SWIG_0(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ConvolutionEngine1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ConvolutionEngine1D::ConvolutionEngine1D(unsigned int,unsigned int)\n"
	" npstat::ConvolutionEngine1D::ConvolutionEngine1D(unsigned int)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_ConvolutionEngine1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ConvolutionEngine1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConvolutionEngine1D" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_discardFilter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:ConvolutionEngine1D_discardFilter",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_discardFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConvolutionEngine1D_discardFilter" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (bool)(arg1)->discardFilter(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_dataLength(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:ConvolutionEngine1D_dataLength",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_dataLength" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::ConvolutionEngine1D const *)arg1)->dataLength();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_setFilter__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:ConvolutionEngine1D_setFilter",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_setFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvolutionEngine1D_setFilter" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConvolutionEngine1D_setFilter" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ConvolutionEngine1D_setFilter" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	(arg1)->setFilter2((double const *)arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_setFilter__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ConvolutionEngine1D_setFilter",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_setFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvolutionEngine1D_setFilter" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConvolutionEngine1D_setFilter" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	(arg1)->setFilter2((double const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_setFilter__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	float arg2 = (float ) 0 ;
	unsigned int arg3 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:ConvolutionEngine1D_setFilter",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_setFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvolutionEngine1D_setFilter" "', argument " "2"" of type '" "float const *""'");
	}
	arg2 = reinterpret_cast< float * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConvolutionEngine1D_setFilter" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ConvolutionEngine1D_setFilter" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	(arg1)->setFilter2((float const *)arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_setFilter__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	float arg2 = (float ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ConvolutionEngine1D_setFilter",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_setFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvolutionEngine1D_setFilter" "', argument " "2"" of type '" "float const *""'");
	}
	arg2 = reinterpret_cast< float * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConvolutionEngine1D_setFilter" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	(arg1)->setFilter2((float const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_setFilter(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngine1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngine1D_setFilter__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngine1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngine1D_setFilter__SWIG_5(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngine1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngine1D_setFilter__SWIG_4(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngine1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngine1D_setFilter__SWIG_2(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ConvolutionEngine1D_setFilter'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ConvolutionEngine1D::setFilter2(double const *,unsigned int,unsigned int)\n"
	" npstat::ConvolutionEngine1D::setFilter2(double const *,unsigned int)\n"
	" npstat::ConvolutionEngine1D::setFilter2(float const *,unsigned int,unsigned int)\n"
	" npstat::ConvolutionEngine1D::setFilter2(float const *,unsigned int)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_convolveWithFilter__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	double arg2 = (double ) 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:ConvolutionEngine1D_convolveWithFilter",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "3"" of type '" "double *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	(arg1)->convolveWithFilter2((double const *)arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_convolveWithFilter__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	double arg2 = (double ) 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:ConvolutionEngine1D_convolveWithFilter",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "3"" of type '" "double *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	(arg1)->convolveWithFilter2((double const *)arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_convolveWithFilter__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	float arg2 = (float ) 0 ;
	float arg3 = (float ) 0 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:ConvolutionEngine1D_convolveWithFilter",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "2"" of type '" "float const *""'");
	}
	arg2 = reinterpret_cast< float * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "3"" of type '" "float *""'");
	}
	arg3 = reinterpret_cast< float * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	(arg1)->convolveWithFilter2((float const *)arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_convolveWithFilter__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	float arg2 = (float ) 0 ;
	float arg3 = (float ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:ConvolutionEngine1D_convolveWithFilter",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "2"" of type '" "float const *""'");
	}
	arg2 = reinterpret_cast< float * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "3"" of type '" "float *""'");
	}
	arg3 = reinterpret_cast< float * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ConvolutionEngine1D_convolveWithFilter" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	(arg1)->convolveWithFilter2((float const *)arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_convolveWithFilter(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngine1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngine1D_convolveWithFilter__SWIG_3(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngine1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngine1D_convolveWithFilter__SWIG_5(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngine1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngine1D_convolveWithFilter__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngine1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngine1D_convolveWithFilter__SWIG_2(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ConvolutionEngine1D_convolveWithFilter'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ConvolutionEngine1D::convolveWithFilter2(double const ,double ,unsigned int,unsigned int)\n"
	" npstat::ConvolutionEngine1D::convolveWithFilter2(double const ,double ,unsigned int)\n"
	" npstat::ConvolutionEngine1D::convolveWithFilter2(float const ,float ,unsigned int,unsigned int)\n"
	" npstat::ConvolutionEngine1D::convolveWithFilter2(float const ,float ,unsigned int)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_depositFilter__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	unsigned long arg2 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:ConvolutionEngine1D_depositFilter",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	(arg1)->depositFilter2(arg2,(double const *)arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_depositFilter__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	unsigned long arg2 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:ConvolutionEngine1D_depositFilter",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	(arg1)->depositFilter2(arg2,(double const *)arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_depositFilter__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	unsigned long arg2 ;
	float arg3 = (float ) 0 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:ConvolutionEngine1D_depositFilter",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "3"" of type '" "float const *""'");
	}
	arg3 = reinterpret_cast< float * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	(arg1)->depositFilter2(arg2,(float const *)arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_depositFilter__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	unsigned long arg2 ;
	float arg3 = (float ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:ConvolutionEngine1D_depositFilter",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "3"" of type '" "float const *""'");
	}
	arg3 = reinterpret_cast< float * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ConvolutionEngine1D_depositFilter" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	(arg1)->depositFilter2(arg2,(float const *)arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_depositFilter(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngine1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngine1D_depositFilter__SWIG_3(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngine1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngine1D_depositFilter__SWIG_5(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngine1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngine1D_depositFilter__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngine1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngine1D_depositFilter__SWIG_2(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ConvolutionEngine1D_depositFilter'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ConvolutionEngine1D::depositFilter2(unsigned long,double const *,unsigned int,unsigned int)\n"
	" npstat::ConvolutionEngine1D::depositFilter2(unsigned long,double const *,unsigned int)\n"
	" npstat::ConvolutionEngine1D::depositFilter2(unsigned long,float const *,unsigned int,unsigned int)\n"
	" npstat::ConvolutionEngine1D::depositFilter2(unsigned long,float const *,unsigned int)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_convolveWithDeposit__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	unsigned long arg2 ;
	double arg3 = (double ) 0 ;
	double arg4 = (double ) 0 ;
	unsigned int arg5 ;
	unsigned int arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ConvolutionEngine1D_convolveWithDeposit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "4"" of type '" "double *""'");
	}
	arg4 = reinterpret_cast< double * >(argp4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	{
	try {
	(arg1)->convolveWithDeposit2(arg2,(double const *)arg3,arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_convolveWithDeposit__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	unsigned long arg2 ;
	double arg3 = (double ) 0 ;
	double arg4 = (double ) 0 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:ConvolutionEngine1D_convolveWithDeposit",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "4"" of type '" "double *""'");
	}
	arg4 = reinterpret_cast< double * >(argp4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	(arg1)->convolveWithDeposit2(arg2,(double const *)arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_convolveWithDeposit__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	unsigned long arg2 ;
	float arg3 = (float ) 0 ;
	float arg4 = (float ) 0 ;
	unsigned int arg5 ;
	unsigned int arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ConvolutionEngine1D_convolveWithDeposit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "3"" of type '" "float const *""'");
	}
	arg3 = reinterpret_cast< float * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "4"" of type '" "float *""'");
	}
	arg4 = reinterpret_cast< float * >(argp4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	{
	try {
	(arg1)->convolveWithDeposit2(arg2,(float const *)arg3,arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_convolveWithDeposit__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngine1D arg1 = (npstat::ConvolutionEngine1D ) 0 ;
	unsigned long arg2 ;
	float arg3 = (float ) 0 ;
	float arg4 = (float ) 0 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:ConvolutionEngine1D_convolveWithDeposit",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngine1D, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "1"" of type '" "npstat::ConvolutionEngine1D *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngine1D * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "3"" of type '" "float const *""'");
	}
	arg3 = reinterpret_cast< float * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "4"" of type '" "float *""'");
	}
	arg4 = reinterpret_cast< float * >(argp4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ConvolutionEngine1D_convolveWithDeposit" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	(arg1)->convolveWithDeposit2(arg2,(float const *)arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngine1D_convolveWithDeposit(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[7] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 6) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngine1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngine1D_convolveWithDeposit__SWIG_3(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngine1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngine1D_convolveWithDeposit__SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngine1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngine1D_convolveWithDeposit__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngine1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngine1D_convolveWithDeposit__SWIG_2(self, args);
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ConvolutionEngine1D_convolveWithDeposit'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ConvolutionEngine1D::convolveWithDeposit2(unsigned long,double const ,double ,unsigned int,unsigned int)\n"
	" npstat::ConvolutionEngine1D::convolveWithDeposit2(unsigned long,double const ,double ,unsigned int)\n"
	" npstat::ConvolutionEngine1D::convolveWithDeposit2(unsigned long,float const ,float ,unsigned int,unsigned int)\n"
	" npstat::ConvolutionEngine1D::convolveWithDeposit2(unsigned long,float const ,float ,unsigned int)\n");
	return 0;
	}


	SWIGINTERN PyObject ConvolutionEngine1D_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ConvolutionEngine1D, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_GaussHermiteQuadrature(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::GaussHermiteQuadrature *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_GaussHermiteQuadrature",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GaussHermiteQuadrature" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	{
	try {
	result = (npstat::GaussHermiteQuadrature *)new npstat::GaussHermiteQuadrature(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__GaussHermiteQuadrature, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussHermiteQuadrature_npoints(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussHermiteQuadrature arg1 = (npstat::GaussHermiteQuadrature ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussHermiteQuadrature_npoints",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussHermiteQuadrature, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussHermiteQuadrature_npoints" "', argument " "1"" of type '" "npstat::GaussHermiteQuadrature const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussHermiteQuadrature * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::GaussHermiteQuadrature const *)arg1)->npoints();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussHermiteQuadrature_isAllowed(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussHermiteQuadrature_isAllowed",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GaussHermiteQuadrature_isAllowed" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	{
	try {
	result = (bool)npstat::GaussHermiteQuadrature::isAllowed(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussHermiteQuadrature_allowedNPonts(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< unsigned int,std::allocator< unsigned int > > result;

	if (!PyArg_ParseTuple(args,(char *)":GaussHermiteQuadrature_allowedNPonts")) SWIG_fail;
	{
	try {
	result = npstat::GaussHermiteQuadrature::allowedNPonts();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussHermiteQuadrature_minimalExactRule(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussHermiteQuadrature_minimalExactRule",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GaussHermiteQuadrature_minimalExactRule" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	{
	try {
	result = (unsigned int)npstat::GaussHermiteQuadrature::minimalExactRule(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussHermiteQuadrature_getAbscissae(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussHermiteQuadrature arg1 = (npstat::GaussHermiteQuadrature ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< double,std::allocator< double > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussHermiteQuadrature_getAbscissae",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussHermiteQuadrature, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussHermiteQuadrature_getAbscissae" "', argument " "1"" of type '" "npstat::GaussHermiteQuadrature const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussHermiteQuadrature * >(argp1);
	{
	try {
	result = ((npstat::GaussHermiteQuadrature const *)arg1)->abscissae2();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussHermiteQuadrature_getWeights(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussHermiteQuadrature arg1 = (npstat::GaussHermiteQuadrature ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< double,std::allocator< double > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:GaussHermiteQuadrature_getWeights",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussHermiteQuadrature, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussHermiteQuadrature_getWeights" "', argument " "1"" of type '" "npstat::GaussHermiteQuadrature const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussHermiteQuadrature * >(argp1);
	{
	try {
	result = ((npstat::GaussHermiteQuadrature const *)arg1)->weights2();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_GaussHermiteQuadrature_integrate(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussHermiteQuadrature arg1 = (npstat::GaussHermiteQuadrature ) 0 ;
	npstat::Functor1< double,double > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	long double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:GaussHermiteQuadrature_integrate",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussHermiteQuadrature, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussHermiteQuadrature_integrate" "', argument " "1"" of type '" "npstat::GaussHermiteQuadrature const *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussHermiteQuadrature * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__Functor1T_double_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussHermiteQuadrature_integrate" "', argument " "2"" of type '" "npstat::Functor1< double,double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussHermiteQuadrature_integrate" "', argument " "2"" of type '" "npstat::Functor1< double,double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::Functor1< double,double > * >(argp2);
	{
	try {
	result = (long double)((npstat::GaussHermiteQuadrature const )arg1)->SWIGTEMPLATEDISAMBIGUATOR integrate< double,double >((npstat::Functor1< double,double > const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new long double(static_cast< const long double& >(result))), SWIGTYPE_p_long_double, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_GaussHermiteQuadrature(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::GaussHermiteQuadrature arg1 = (npstat::GaussHermiteQuadrature ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_GaussHermiteQuadrature",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__GaussHermiteQuadrature, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GaussHermiteQuadrature" "', argument " "1"" of type '" "npstat::GaussHermiteQuadrature *""'");
	}
	arg1 = reinterpret_cast< npstat::GaussHermiteQuadrature * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject GaussHermiteQuadrature_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__GaussHermiteQuadrature, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_FejerQuadrature(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::FejerQuadrature *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_FejerQuadrature",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FejerQuadrature" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	{
	try {
	result = (npstat::FejerQuadrature *)new npstat::FejerQuadrature(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__FejerQuadrature, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FejerQuadrature_npoints(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::FejerQuadrature arg1 = (npstat::FejerQuadrature ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:FejerQuadrature_npoints",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__FejerQuadrature, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FejerQuadrature_npoints" "', argument " "1"" of type '" "npstat::FejerQuadrature const *""'");
	}
	arg1 = reinterpret_cast< npstat::FejerQuadrature * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::FejerQuadrature const *)arg1)->npoints();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FejerQuadrature_minimalExactRule(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:FejerQuadrature_minimalExactRule",&obj0)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FejerQuadrature_minimalExactRule" "', argument " "1"" of type '" "unsigned int""'");
	}
	arg1 = static_cast< unsigned int >(val1);
	{
	try {
	result = (unsigned int)npstat::FejerQuadrature::minimalExactRule(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FejerQuadrature_getAbscissae(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::FejerQuadrature arg1 = (npstat::FejerQuadrature ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< double,std::allocator< double > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:FejerQuadrature_getAbscissae",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__FejerQuadrature, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FejerQuadrature_getAbscissae" "', argument " "1"" of type '" "npstat::FejerQuadrature const *""'");
	}
	arg1 = reinterpret_cast< npstat::FejerQuadrature * >(argp1);
	{
	try {
	result = ((npstat::FejerQuadrature const *)arg1)->abscissae2();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FejerQuadrature_getWeights(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::FejerQuadrature arg1 = (npstat::FejerQuadrature ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< double,std::allocator< double > > result;

	if (!PyArg_ParseTuple(args,(char *)"O:FejerQuadrature_getWeights",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__FejerQuadrature, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FejerQuadrature_getWeights" "', argument " "1"" of type '" "npstat::FejerQuadrature const *""'");
	}
	arg1 = reinterpret_cast< npstat::FejerQuadrature * >(argp1);
	{
	try {
	result = ((npstat::FejerQuadrature const *)arg1)->weights2();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FejerQuadrature_integrate(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::FejerQuadrature arg1 = (npstat::FejerQuadrature ) 0 ;
	npstat::Functor1< double,double > *arg2 = 0 ;
	long double arg3 ;
	long double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 ;
	int res3 = 0 ;
	void *argp4 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	long double result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:FejerQuadrature_integrate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__FejerQuadrature, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FejerQuadrature_integrate" "', argument " "1"" of type '" "npstat::FejerQuadrature const *""'");
	}
	arg1 = reinterpret_cast< npstat::FejerQuadrature * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__Functor1T_double_double_t, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FejerQuadrature_integrate" "', argument " "2"" of type '" "npstat::Functor1< double,double > const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FejerQuadrature_integrate" "', argument " "2"" of type '" "npstat::Functor1< double,double > const &""'");
	}
	arg2 = reinterpret_cast< npstat::Functor1< double,double > * >(argp2);
	{
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_long_double, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FejerQuadrature_integrate" "', argument " "3"" of type '" "long double""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FejerQuadrature_integrate" "', argument " "3"" of type '" "long double""'");
	} else {
	long double * temp = reinterpret_cast< long double * >(argp3);
	arg3 = *temp;
	if (SWIG_IsNewObj(res3)) delete temp;
	}
	}
	{
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_long_double, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FejerQuadrature_integrate" "', argument " "4"" of type '" "long double""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FejerQuadrature_integrate" "', argument " "4"" of type '" "long double""'");
	} else {
	long double * temp = reinterpret_cast< long double * >(argp4);
	arg4 = *temp;
	if (SWIG_IsNewObj(res4)) delete temp;
	}
	}
	{
	try {
	result = (long double)((npstat::FejerQuadrature const )arg1)->SWIGTEMPLATEDISAMBIGUATOR integrate< double,double >((npstat::Functor1< double,double > const &)arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new long double(static_cast< const long double& >(result))), SWIGTYPE_p_long_double, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_FejerQuadrature(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::FejerQuadrature arg1 = (npstat::FejerQuadrature ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FejerQuadrature",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__FejerQuadrature, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FejerQuadrature" "', argument " "1"" of type '" "npstat::FejerQuadrature *""'");
	}
	arg1 = reinterpret_cast< npstat::FejerQuadrature * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FejerQuadrature_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__FejerQuadrature, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_UCharBoxNDScanner__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxND< unsigned char > *arg1 = 0 ;
	std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::BoxNDScanner< unsigned char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_UCharBoxNDScanner",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__BoxNDT_unsigned_char_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UCharBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< unsigned char > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UCharBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< unsigned char > const &""'");
	}
	arg1 = reinterpret_cast< npstat::BoxND< unsigned char > * >(argp1);
	{
	std::vector< unsigned int,std::allocator< unsigned int > > ptr = (std::vector< unsigned int,std::allocator< unsigned int > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UCharBoxNDScanner" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UCharBoxNDScanner" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'");
	}
	arg2 = ptr;
	}
	{
	try {
	result = (npstat::BoxNDScanner< unsigned char > )new npstat::BoxNDScanner< unsigned char >((npstat::BoxND< unsigned char > const &)arg1,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__BoxNDScannerT_unsigned_char_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_UCharBoxNDScanner__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxND< unsigned char > *arg1 = 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::BoxNDScanner< unsigned char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_UCharBoxNDScanner",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__BoxNDT_unsigned_char_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UCharBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< unsigned char > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UCharBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< unsigned char > const &""'");
	}
	arg1 = reinterpret_cast< npstat::BoxND< unsigned char > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UCharBoxNDScanner" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_UCharBoxNDScanner" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (npstat::BoxNDScanner< unsigned char > )new npstat::BoxNDScanner< unsigned char >((npstat::BoxND< unsigned char > const &)arg1,(unsigned int const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__BoxNDScannerT_unsigned_char_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_UCharBoxNDScanner(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoxNDT_unsigned_char_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[1], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_UCharBoxNDScanner__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoxNDT_unsigned_char_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_UCharBoxNDScanner__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UCharBoxNDScanner'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::BoxNDScanner< unsigned char >::BoxNDScanner(npstat::BoxND< unsigned char > const &,std::vector< unsigned int,std::allocator< unsigned int > > const &)\n"
	" npstat::BoxNDScanner< unsigned char >::BoxNDScanner(npstat::BoxND< unsigned char > const &,unsigned int const *,unsigned int const)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_UCharBoxNDScanner_dim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< unsigned char > arg1 = (npstat::BoxNDScanner< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharBoxNDScanner_dim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharBoxNDScanner_dim" "', argument " "1"" of type '" "npstat::BoxNDScanner< unsigned char > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< unsigned char > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::BoxNDScanner< unsigned char > const *)arg1)->dim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharBoxNDScanner_state(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< unsigned char > arg1 = (npstat::BoxNDScanner< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharBoxNDScanner_state",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharBoxNDScanner_state" "', argument " "1"" of type '" "npstat::BoxNDScanner< unsigned char > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< unsigned char > * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::BoxNDScanner< unsigned char > const *)arg1)->state();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharBoxNDScanner_maxState(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< unsigned char > arg1 = (npstat::BoxNDScanner< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharBoxNDScanner_maxState",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharBoxNDScanner_maxState" "', argument " "1"" of type '" "npstat::BoxNDScanner< unsigned char > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< unsigned char > * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::BoxNDScanner< unsigned char > const *)arg1)->maxState();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharBoxNDScanner_isValid(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< unsigned char > arg1 = (npstat::BoxNDScanner< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharBoxNDScanner_isValid",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharBoxNDScanner_isValid" "', argument " "1"" of type '" "npstat::BoxNDScanner< unsigned char > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< unsigned char > * >(argp1);
	{
	try {
	result = (bool)((npstat::BoxNDScanner< unsigned char > const *)arg1)->isValid();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharBoxNDScanner_getCoords(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< unsigned char > arg1 = (npstat::BoxNDScanner< unsigned char > ) 0 ;
	unsigned char arg2 = (unsigned char ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:UCharBoxNDScanner_getCoords",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharBoxNDScanner_getCoords" "', argument " "1"" of type '" "npstat::BoxNDScanner< unsigned char > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< unsigned char > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UCharBoxNDScanner_getCoords" "', argument " "2"" of type '" "unsigned char *""'");
	}
	arg2 = reinterpret_cast< unsigned char * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UCharBoxNDScanner_getCoords" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	((npstat::BoxNDScanner< unsigned char > const *)arg1)->getCoords(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharBoxNDScanner_getIndex(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< unsigned char > arg1 = (npstat::BoxNDScanner< unsigned char > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:UCharBoxNDScanner_getIndex",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharBoxNDScanner_getIndex" "', argument " "1"" of type '" "npstat::BoxNDScanner< unsigned char > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< unsigned char > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UCharBoxNDScanner_getIndex" "', argument " "2"" of type '" "unsigned int *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UCharBoxNDScanner_getIndex" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	((npstat::BoxNDScanner< unsigned char > const *)arg1)->getIndex(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharBoxNDScanner_reset(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< unsigned char > arg1 = (npstat::BoxNDScanner< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:UCharBoxNDScanner_reset",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharBoxNDScanner_reset" "', argument " "1"" of type '" "npstat::BoxNDScanner< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< unsigned char > * >(argp1);
	{
	try {
	(arg1)->reset();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_UCharBoxNDScanner_setState(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< unsigned char > arg1 = (npstat::BoxNDScanner< unsigned char > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:UCharBoxNDScanner_setState",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UCharBoxNDScanner_setState" "', argument " "1"" of type '" "npstat::BoxNDScanner< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< unsigned char > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UCharBoxNDScanner_setState" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	(arg1)->setState(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_UCharBoxNDScanner(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< unsigned char > arg1 = (npstat::BoxNDScanner< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_UCharBoxNDScanner",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_unsigned_char_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UCharBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxNDScanner< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< unsigned char > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject UCharBoxNDScanner_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__BoxNDScannerT_unsigned_char_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_IntBoxNDScanner__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxND< int > *arg1 = 0 ;
	std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::BoxNDScanner< int > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_IntBoxNDScanner",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__BoxNDT_int_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< int > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< int > const &""'");
	}
	arg1 = reinterpret_cast< npstat::BoxND< int > * >(argp1);
	{
	std::vector< unsigned int,std::allocator< unsigned int > > ptr = (std::vector< unsigned int,std::allocator< unsigned int > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_IntBoxNDScanner" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntBoxNDScanner" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'");
	}
	arg2 = ptr;
	}
	{
	try {
	result = (npstat::BoxNDScanner< int > )new npstat::BoxNDScanner< int >((npstat::BoxND< int > const &)arg1,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__BoxNDScannerT_int_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_IntBoxNDScanner__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxND< int > *arg1 = 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::BoxNDScanner< int > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_IntBoxNDScanner",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__BoxNDT_int_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< int > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< int > const &""'");
	}
	arg1 = reinterpret_cast< npstat::BoxND< int > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_IntBoxNDScanner" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_IntBoxNDScanner" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (npstat::BoxNDScanner< int > )new npstat::BoxNDScanner< int >((npstat::BoxND< int > const &)arg1,(unsigned int const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__BoxNDScannerT_int_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_IntBoxNDScanner(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoxNDT_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[1], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_IntBoxNDScanner__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoxNDT_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_IntBoxNDScanner__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_IntBoxNDScanner'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::BoxNDScanner< int >::BoxNDScanner(npstat::BoxND< int > const &,std::vector< unsigned int,std::allocator< unsigned int > > const &)\n"
	" npstat::BoxNDScanner< int >::BoxNDScanner(npstat::BoxND< int > const &,unsigned int const *,unsigned int const)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_IntBoxNDScanner_dim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< int > arg1 = (npstat::BoxNDScanner< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:IntBoxNDScanner_dim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntBoxNDScanner_dim" "', argument " "1"" of type '" "npstat::BoxNDScanner< int > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< int > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::BoxNDScanner< int > const *)arg1)->dim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntBoxNDScanner_state(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< int > arg1 = (npstat::BoxNDScanner< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:IntBoxNDScanner_state",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntBoxNDScanner_state" "', argument " "1"" of type '" "npstat::BoxNDScanner< int > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< int > * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::BoxNDScanner< int > const *)arg1)->state();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntBoxNDScanner_maxState(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< int > arg1 = (npstat::BoxNDScanner< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:IntBoxNDScanner_maxState",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntBoxNDScanner_maxState" "', argument " "1"" of type '" "npstat::BoxNDScanner< int > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< int > * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::BoxNDScanner< int > const *)arg1)->maxState();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntBoxNDScanner_isValid(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< int > arg1 = (npstat::BoxNDScanner< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:IntBoxNDScanner_isValid",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntBoxNDScanner_isValid" "', argument " "1"" of type '" "npstat::BoxNDScanner< int > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< int > * >(argp1);
	{
	try {
	result = (bool)((npstat::BoxNDScanner< int > const *)arg1)->isValid();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntBoxNDScanner_getCoords(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< int > arg1 = (npstat::BoxNDScanner< int > ) 0 ;
	int arg2 = (int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:IntBoxNDScanner_getCoords",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntBoxNDScanner_getCoords" "', argument " "1"" of type '" "npstat::BoxNDScanner< int > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< int > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntBoxNDScanner_getCoords" "', argument " "2"" of type '" "int *""'");
	}
	arg2 = reinterpret_cast< int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntBoxNDScanner_getCoords" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	((npstat::BoxNDScanner< int > const *)arg1)->getCoords(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntBoxNDScanner_getIndex(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< int > arg1 = (npstat::BoxNDScanner< int > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:IntBoxNDScanner_getIndex",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntBoxNDScanner_getIndex" "', argument " "1"" of type '" "npstat::BoxNDScanner< int > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< int > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntBoxNDScanner_getIndex" "', argument " "2"" of type '" "unsigned int *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntBoxNDScanner_getIndex" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	((npstat::BoxNDScanner< int > const *)arg1)->getIndex(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntBoxNDScanner_reset(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< int > arg1 = (npstat::BoxNDScanner< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:IntBoxNDScanner_reset",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntBoxNDScanner_reset" "', argument " "1"" of type '" "npstat::BoxNDScanner< int > *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< int > * >(argp1);
	{
	try {
	(arg1)->reset();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_IntBoxNDScanner_setState(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< int > arg1 = (npstat::BoxNDScanner< int > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:IntBoxNDScanner_setState",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntBoxNDScanner_setState" "', argument " "1"" of type '" "npstat::BoxNDScanner< int > *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< int > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntBoxNDScanner_setState" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	(arg1)->setState(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_IntBoxNDScanner(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< int > arg1 = (npstat::BoxNDScanner< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_IntBoxNDScanner",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_int_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxNDScanner< int > *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< int > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject IntBoxNDScanner_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__BoxNDScannerT_int_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_LLongBoxNDScanner__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxND< long long > *arg1 = 0 ;
	std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::BoxNDScanner< long long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_LLongBoxNDScanner",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__BoxNDT_long_long_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LLongBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< long long > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LLongBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< long long > const &""'");
	}
	arg1 = reinterpret_cast< npstat::BoxND< long long > * >(argp1);
	{
	std::vector< unsigned int,std::allocator< unsigned int > > ptr = (std::vector< unsigned int,std::allocator< unsigned int > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LLongBoxNDScanner" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LLongBoxNDScanner" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'");
	}
	arg2 = ptr;
	}
	{
	try {
	result = (npstat::BoxNDScanner< long long > )new npstat::BoxNDScanner< long long >((npstat::BoxND< long long > const &)arg1,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__BoxNDScannerT_long_long_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LLongBoxNDScanner__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxND< long long > *arg1 = 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::BoxNDScanner< long long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_LLongBoxNDScanner",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__BoxNDT_long_long_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LLongBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< long long > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LLongBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< long long > const &""'");
	}
	arg1 = reinterpret_cast< npstat::BoxND< long long > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LLongBoxNDScanner" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_LLongBoxNDScanner" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (npstat::BoxNDScanner< long long > )new npstat::BoxNDScanner< long long >((npstat::BoxND< long long > const &)arg1,(unsigned int const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__BoxNDScannerT_long_long_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_LLongBoxNDScanner(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoxNDT_long_long_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[1], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_LLongBoxNDScanner__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoxNDT_long_long_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_LLongBoxNDScanner__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_LLongBoxNDScanner'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::BoxNDScanner< long long >::BoxNDScanner(npstat::BoxND< long long > const &,std::vector< unsigned int,std::allocator< unsigned int > > const &)\n"
	" npstat::BoxNDScanner< long long >::BoxNDScanner(npstat::BoxND< long long > const &,unsigned int const *,unsigned int const)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_LLongBoxNDScanner_dim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< long long > arg1 = (npstat::BoxNDScanner< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongBoxNDScanner_dim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongBoxNDScanner_dim" "', argument " "1"" of type '" "npstat::BoxNDScanner< long long > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< long long > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::BoxNDScanner< long long > const *)arg1)->dim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongBoxNDScanner_state(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< long long > arg1 = (npstat::BoxNDScanner< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongBoxNDScanner_state",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongBoxNDScanner_state" "', argument " "1"" of type '" "npstat::BoxNDScanner< long long > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< long long > * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::BoxNDScanner< long long > const *)arg1)->state();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongBoxNDScanner_maxState(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< long long > arg1 = (npstat::BoxNDScanner< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongBoxNDScanner_maxState",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongBoxNDScanner_maxState" "', argument " "1"" of type '" "npstat::BoxNDScanner< long long > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< long long > * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::BoxNDScanner< long long > const *)arg1)->maxState();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongBoxNDScanner_isValid(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< long long > arg1 = (npstat::BoxNDScanner< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongBoxNDScanner_isValid",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongBoxNDScanner_isValid" "', argument " "1"" of type '" "npstat::BoxNDScanner< long long > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< long long > * >(argp1);
	{
	try {
	result = (bool)((npstat::BoxNDScanner< long long > const *)arg1)->isValid();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongBoxNDScanner_getCoords(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< long long > arg1 = (npstat::BoxNDScanner< long long > ) 0 ;
	long long arg2 = (long long ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LLongBoxNDScanner_getCoords",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongBoxNDScanner_getCoords" "', argument " "1"" of type '" "npstat::BoxNDScanner< long long > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< long long > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_long_long, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LLongBoxNDScanner_getCoords" "', argument " "2"" of type '" "long long *""'");
	}
	arg2 = reinterpret_cast< long long * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LLongBoxNDScanner_getCoords" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	((npstat::BoxNDScanner< long long > const *)arg1)->getCoords(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongBoxNDScanner_getIndex(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< long long > arg1 = (npstat::BoxNDScanner< long long > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:LLongBoxNDScanner_getIndex",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongBoxNDScanner_getIndex" "', argument " "1"" of type '" "npstat::BoxNDScanner< long long > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< long long > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LLongBoxNDScanner_getIndex" "', argument " "2"" of type '" "unsigned int *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LLongBoxNDScanner_getIndex" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	((npstat::BoxNDScanner< long long > const *)arg1)->getIndex(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongBoxNDScanner_reset(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< long long > arg1 = (npstat::BoxNDScanner< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:LLongBoxNDScanner_reset",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongBoxNDScanner_reset" "', argument " "1"" of type '" "npstat::BoxNDScanner< long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< long long > * >(argp1);
	{
	try {
	(arg1)->reset();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_LLongBoxNDScanner_setState(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< long long > arg1 = (npstat::BoxNDScanner< long long > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:LLongBoxNDScanner_setState",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LLongBoxNDScanner_setState" "', argument " "1"" of type '" "npstat::BoxNDScanner< long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< long long > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LLongBoxNDScanner_setState" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	(arg1)->setState(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_LLongBoxNDScanner(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< long long > arg1 = (npstat::BoxNDScanner< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_LLongBoxNDScanner",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_long_long_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LLongBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxNDScanner< long long > *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< long long > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject LLongBoxNDScanner_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__BoxNDScannerT_long_long_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_FloatBoxNDScanner__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxND< float > *arg1 = 0 ;
	std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::BoxNDScanner< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_FloatBoxNDScanner",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__BoxNDT_float_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< float > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< float > const &""'");
	}
	arg1 = reinterpret_cast< npstat::BoxND< float > * >(argp1);
	{
	std::vector< unsigned int,std::allocator< unsigned int > > ptr = (std::vector< unsigned int,std::allocator< unsigned int > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatBoxNDScanner" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatBoxNDScanner" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'");
	}
	arg2 = ptr;
	}
	{
	try {
	result = (npstat::BoxNDScanner< float > )new npstat::BoxNDScanner< float >((npstat::BoxND< float > const &)arg1,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__BoxNDScannerT_float_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatBoxNDScanner__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxND< float > *arg1 = 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::BoxNDScanner< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_FloatBoxNDScanner",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__BoxNDT_float_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FloatBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< float > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FloatBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< float > const &""'");
	}
	arg1 = reinterpret_cast< npstat::BoxND< float > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FloatBoxNDScanner" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FloatBoxNDScanner" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (npstat::BoxNDScanner< float > )new npstat::BoxNDScanner< float >((npstat::BoxND< float > const &)arg1,(unsigned int const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__BoxNDScannerT_float_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_FloatBoxNDScanner(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoxNDT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[1], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_FloatBoxNDScanner__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoxNDT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_FloatBoxNDScanner__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FloatBoxNDScanner'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::BoxNDScanner< float >::BoxNDScanner(npstat::BoxND< float > const &,std::vector< unsigned int,std::allocator< unsigned int > > const &)\n"
	" npstat::BoxNDScanner< float >::BoxNDScanner(npstat::BoxND< float > const &,unsigned int const *,unsigned int const)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_FloatBoxNDScanner_dim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< float > arg1 = (npstat::BoxNDScanner< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatBoxNDScanner_dim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatBoxNDScanner_dim" "', argument " "1"" of type '" "npstat::BoxNDScanner< float > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< float > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::BoxNDScanner< float > const *)arg1)->dim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatBoxNDScanner_state(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< float > arg1 = (npstat::BoxNDScanner< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatBoxNDScanner_state",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatBoxNDScanner_state" "', argument " "1"" of type '" "npstat::BoxNDScanner< float > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< float > * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::BoxNDScanner< float > const *)arg1)->state();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatBoxNDScanner_maxState(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< float > arg1 = (npstat::BoxNDScanner< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatBoxNDScanner_maxState",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatBoxNDScanner_maxState" "', argument " "1"" of type '" "npstat::BoxNDScanner< float > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< float > * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::BoxNDScanner< float > const *)arg1)->maxState();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatBoxNDScanner_isValid(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< float > arg1 = (npstat::BoxNDScanner< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatBoxNDScanner_isValid",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatBoxNDScanner_isValid" "', argument " "1"" of type '" "npstat::BoxNDScanner< float > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< float > * >(argp1);
	{
	try {
	result = (bool)((npstat::BoxNDScanner< float > const *)arg1)->isValid();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatBoxNDScanner_getCoords(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< float > arg1 = (npstat::BoxNDScanner< float > ) 0 ;
	float arg2 = (float ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:FloatBoxNDScanner_getCoords",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatBoxNDScanner_getCoords" "', argument " "1"" of type '" "npstat::BoxNDScanner< float > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< float > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatBoxNDScanner_getCoords" "', argument " "2"" of type '" "float *""'");
	}
	arg2 = reinterpret_cast< float * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatBoxNDScanner_getCoords" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	((npstat::BoxNDScanner< float > const *)arg1)->getCoords(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatBoxNDScanner_getIndex(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< float > arg1 = (npstat::BoxNDScanner< float > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:FloatBoxNDScanner_getIndex",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatBoxNDScanner_getIndex" "', argument " "1"" of type '" "npstat::BoxNDScanner< float > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< float > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FloatBoxNDScanner_getIndex" "', argument " "2"" of type '" "unsigned int *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FloatBoxNDScanner_getIndex" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	((npstat::BoxNDScanner< float > const *)arg1)->getIndex(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatBoxNDScanner_reset(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< float > arg1 = (npstat::BoxNDScanner< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:FloatBoxNDScanner_reset",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatBoxNDScanner_reset" "', argument " "1"" of type '" "npstat::BoxNDScanner< float > *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< float > * >(argp1);
	{
	try {
	(arg1)->reset();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_FloatBoxNDScanner_setState(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< float > arg1 = (npstat::BoxNDScanner< float > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:FloatBoxNDScanner_setState",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FloatBoxNDScanner_setState" "', argument " "1"" of type '" "npstat::BoxNDScanner< float > *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< float > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FloatBoxNDScanner_setState" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	(arg1)->setState(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_FloatBoxNDScanner(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< float > arg1 = (npstat::BoxNDScanner< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_FloatBoxNDScanner",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_float_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FloatBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxNDScanner< float > *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< float > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject FloatBoxNDScanner_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__BoxNDScannerT_float_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_DoubleBoxNDScanner__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxND< double > *arg1 = 0 ;
	std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::BoxNDScanner< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_DoubleBoxNDScanner",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__BoxNDT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< double > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< double > const &""'");
	}
	arg1 = reinterpret_cast< npstat::BoxND< double > * >(argp1);
	{
	std::vector< unsigned int,std::allocator< unsigned int > > ptr = (std::vector< unsigned int,std::allocator< unsigned int > > )0;
	res2 = swig::asptr(obj1, &ptr);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleBoxNDScanner" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleBoxNDScanner" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'");
	}
	arg2 = ptr;
	}
	{
	try {
	result = (npstat::BoxNDScanner< double > )new npstat::BoxNDScanner< double >((npstat::BoxND< double > const &)arg1,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__BoxNDScannerT_double_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res2)) delete arg2;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res2)) delete arg2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleBoxNDScanner__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxND< double > *arg1 = 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::BoxNDScanner< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_DoubleBoxNDScanner",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__BoxNDT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< double > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DoubleBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxND< double > const &""'");
	}
	arg1 = reinterpret_cast< npstat::BoxND< double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleBoxNDScanner" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DoubleBoxNDScanner" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (npstat::BoxNDScanner< double > )new npstat::BoxNDScanner< double >((npstat::BoxND< double > const &)arg1,(unsigned int const *)arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__BoxNDScannerT_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_DoubleBoxNDScanner(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoxNDT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = swig::asptr(argv[1], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_DoubleBoxNDScanner__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoxNDT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_DoubleBoxNDScanner__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_DoubleBoxNDScanner'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::BoxNDScanner< double >::BoxNDScanner(npstat::BoxND< double > const &,std::vector< unsigned int,std::allocator< unsigned int > > const &)\n"
	" npstat::BoxNDScanner< double >::BoxNDScanner(npstat::BoxND< double > const &,unsigned int const *,unsigned int const)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_DoubleBoxNDScanner_dim(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< double > arg1 = (npstat::BoxNDScanner< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleBoxNDScanner_dim",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleBoxNDScanner_dim" "', argument " "1"" of type '" "npstat::BoxNDScanner< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< double > * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::BoxNDScanner< double > const *)arg1)->dim();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleBoxNDScanner_state(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< double > arg1 = (npstat::BoxNDScanner< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleBoxNDScanner_state",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleBoxNDScanner_state" "', argument " "1"" of type '" "npstat::BoxNDScanner< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< double > * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::BoxNDScanner< double > const *)arg1)->state();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleBoxNDScanner_maxState(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< double > arg1 = (npstat::BoxNDScanner< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleBoxNDScanner_maxState",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleBoxNDScanner_maxState" "', argument " "1"" of type '" "npstat::BoxNDScanner< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< double > * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::BoxNDScanner< double > const *)arg1)->maxState();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleBoxNDScanner_isValid(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< double > arg1 = (npstat::BoxNDScanner< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleBoxNDScanner_isValid",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleBoxNDScanner_isValid" "', argument " "1"" of type '" "npstat::BoxNDScanner< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< double > * >(argp1);
	{
	try {
	result = (bool)((npstat::BoxNDScanner< double > const *)arg1)->isValid();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleBoxNDScanner_getCoords(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< double > arg1 = (npstat::BoxNDScanner< double > ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleBoxNDScanner_getCoords",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleBoxNDScanner_getCoords" "', argument " "1"" of type '" "npstat::BoxNDScanner< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleBoxNDScanner_getCoords" "', argument " "2"" of type '" "double *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleBoxNDScanner_getCoords" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	((npstat::BoxNDScanner< double > const *)arg1)->getCoords(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleBoxNDScanner_getIndex(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< double > arg1 = (npstat::BoxNDScanner< double > ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:DoubleBoxNDScanner_getIndex",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleBoxNDScanner_getIndex" "', argument " "1"" of type '" "npstat::BoxNDScanner< double > const *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< double > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleBoxNDScanner_getIndex" "', argument " "2"" of type '" "unsigned int *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleBoxNDScanner_getIndex" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	((npstat::BoxNDScanner< double > const *)arg1)->getIndex(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleBoxNDScanner_reset(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< double > arg1 = (npstat::BoxNDScanner< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:DoubleBoxNDScanner_reset",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleBoxNDScanner_reset" "', argument " "1"" of type '" "npstat::BoxNDScanner< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< double > * >(argp1);
	{
	try {
	(arg1)->reset();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_DoubleBoxNDScanner_setState(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< double > arg1 = (npstat::BoxNDScanner< double > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:DoubleBoxNDScanner_setState",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleBoxNDScanner_setState" "', argument " "1"" of type '" "npstat::BoxNDScanner< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< double > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleBoxNDScanner_setState" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	(arg1)->setState(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_DoubleBoxNDScanner(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::BoxNDScanner< double > arg1 = (npstat::BoxNDScanner< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_DoubleBoxNDScanner",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__BoxNDScannerT_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleBoxNDScanner" "', argument " "1"" of type '" "npstat::BoxNDScanner< double > *""'");
	}
	arg1 = reinterpret_cast< npstat::BoxNDScanner< double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject DoubleBoxNDScanner_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__BoxNDScannerT_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ConvolutionEngineND__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 = (unsigned int ) 0 ;
	unsigned int arg2 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::ConvolutionEngineND *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ConvolutionEngineND",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvolutionEngineND" "', argument " "1"" of type '" "unsigned int const *""'");
	}
	arg1 = reinterpret_cast< unsigned int * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvolutionEngineND" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConvolutionEngineND" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (npstat::ConvolutionEngineND )new npstat::ConvolutionEngineND((unsigned int const )arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConvolutionEngineND, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConvolutionEngineND__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int arg1 = (unsigned int ) 0 ;
	unsigned int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::ConvolutionEngineND *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_ConvolutionEngineND",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvolutionEngineND" "', argument " "1"" of type '" "unsigned int const *""'");
	}
	arg1 = reinterpret_cast< unsigned int * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvolutionEngineND" "', argument " "2"" of type '" "unsigned int""'");
	}
	arg2 = static_cast< unsigned int >(val2);
	{
	try {
	result = (npstat::ConvolutionEngineND )new npstat::ConvolutionEngineND((unsigned int const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ConvolutionEngineND, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ConvolutionEngineND(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConvolutionEngineND__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_ConvolutionEngineND__SWIG_0(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_ConvolutionEngineND'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ConvolutionEngineND::ConvolutionEngineND(unsigned int const *,unsigned int,unsigned int)\n"
	" npstat::ConvolutionEngineND::ConvolutionEngineND(unsigned int const *,unsigned int)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_ConvolutionEngineND(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngineND arg1 = (npstat::ConvolutionEngineND ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ConvolutionEngineND",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngineND, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConvolutionEngineND" "', argument " "1"" of type '" "npstat::ConvolutionEngineND *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngineND * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngineND_discardFilter(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngineND arg1 = (npstat::ConvolutionEngineND ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:ConvolutionEngineND_discardFilter",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngineND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngineND_discardFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngineND *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngineND * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConvolutionEngineND_discardFilter" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (bool)(arg1)->discardFilter(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngineND_isShapeCompatible(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngineND arg1 = (npstat::ConvolutionEngineND ) 0 ;
	unsigned int arg2 = (unsigned int ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:ConvolutionEngineND_isShapeCompatible",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngineND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngineND_isShapeCompatible" "', argument " "1"" of type '" "npstat::ConvolutionEngineND const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngineND * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvolutionEngineND_isShapeCompatible" "', argument " "2"" of type '" "unsigned int const *""'");
	}
	arg2 = reinterpret_cast< unsigned int * >(argp2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConvolutionEngineND_isShapeCompatible" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (bool)((npstat::ConvolutionEngineND const )arg1)->isShapeCompatible((unsigned int const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngineND_rank(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngineND arg1 = (npstat::ConvolutionEngineND ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:ConvolutionEngineND_rank",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngineND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngineND_rank" "', argument " "1"" of type '" "npstat::ConvolutionEngineND const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngineND * >(argp1);
	{
	try {
	result = (unsigned int)((npstat::ConvolutionEngineND const *)arg1)->rank();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngineND_shape(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngineND arg1 = (npstat::ConvolutionEngineND ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:ConvolutionEngineND_shape",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngineND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngineND_shape" "', argument " "1"" of type '" "npstat::ConvolutionEngineND const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngineND * >(argp1);
	{
	try {
	result = (std::vector< unsigned int,std::allocator< unsigned int > > ) &((npstat::ConvolutionEngineND const )arg1)->shape();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(*result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngineND_dataLength(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngineND arg1 = (npstat::ConvolutionEngineND ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:ConvolutionEngineND_dataLength",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngineND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngineND_dataLength" "', argument " "1"" of type '" "npstat::ConvolutionEngineND const *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngineND * >(argp1);
	{
	try {
	result = (unsigned long)((npstat::ConvolutionEngineND const *)arg1)->dataLength();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngineND_setFilter__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngineND arg1 = (npstat::ConvolutionEngineND ) 0 ;
	float arg2 = (float ) 0 ;
	unsigned int arg3 = (unsigned int ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:ConvolutionEngineND_setFilter",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngineND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngineND_setFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngineND *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngineND * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvolutionEngineND_setFilter" "', argument " "2"" of type '" "float const *""'");
	}
	arg2 = reinterpret_cast< float * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngineND_setFilter" "', argument " "3"" of type '" "unsigned int const *""'");
	}
	arg3 = reinterpret_cast< unsigned int * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ConvolutionEngineND_setFilter" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	(arg1)->setFilter2((float const )arg2,(unsigned int const )arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngineND_convolveWithFilter__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngineND arg1 = (npstat::ConvolutionEngineND ) 0 ;
	float arg2 = (float ) 0 ;
	float arg3 = (float ) 0 ;
	unsigned int arg4 = (unsigned int ) 0 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:ConvolutionEngineND_convolveWithFilter",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngineND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngineND_convolveWithFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngineND *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngineND * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvolutionEngineND_convolveWithFilter" "', argument " "2"" of type '" "float const *""'");
	}
	arg2 = reinterpret_cast< float * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngineND_convolveWithFilter" "', argument " "3"" of type '" "float *""'");
	}
	arg3 = reinterpret_cast< float * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConvolutionEngineND_convolveWithFilter" "', argument " "4"" of type '" "unsigned int const *""'");
	}
	arg4 = reinterpret_cast< unsigned int * >(argp4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ConvolutionEngineND_convolveWithFilter" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	(arg1)->convolveWithFilter2((float const )arg2,arg3,(unsigned int const )arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngineND_setFilter__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngineND arg1 = (npstat::ConvolutionEngineND ) 0 ;
	double arg2 = (double ) 0 ;
	unsigned int arg3 = (unsigned int ) 0 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:ConvolutionEngineND_setFilter",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngineND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngineND_setFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngineND *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngineND * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvolutionEngineND_setFilter" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngineND_setFilter" "', argument " "3"" of type '" "unsigned int const *""'");
	}
	arg3 = reinterpret_cast< unsigned int * >(argp3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ConvolutionEngineND_setFilter" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	(arg1)->setFilter2((double const )arg2,(unsigned int const )arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngineND_setFilter(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngineND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngineND_setFilter__SWIG_1(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngineND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngineND_setFilter__SWIG_2(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ConvolutionEngineND_setFilter'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ConvolutionEngineND::setFilter2(float const ,unsigned int const ,unsigned int)\n"
	" npstat::ConvolutionEngineND::setFilter2(double const ,unsigned int const ,unsigned int)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngineND_convolveWithFilter__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngineND arg1 = (npstat::ConvolutionEngineND ) 0 ;
	double arg2 = (double ) 0 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 = (unsigned int ) 0 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:ConvolutionEngineND_convolveWithFilter",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngineND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngineND_convolveWithFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngineND *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngineND * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvolutionEngineND_convolveWithFilter" "', argument " "2"" of type '" "double const *""'");
	}
	arg2 = reinterpret_cast< double * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngineND_convolveWithFilter" "', argument " "3"" of type '" "double *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConvolutionEngineND_convolveWithFilter" "', argument " "4"" of type '" "unsigned int const *""'");
	}
	arg4 = reinterpret_cast< unsigned int * >(argp4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ConvolutionEngineND_convolveWithFilter" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	(arg1)->convolveWithFilter2((double const )arg2,arg3,(unsigned int const )arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngineND_convolveWithFilter(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngineND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngineND_convolveWithFilter__SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngineND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngineND_convolveWithFilter__SWIG_2(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ConvolutionEngineND_convolveWithFilter'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ConvolutionEngineND::convolveWithFilter2(float const ,float ,unsigned int const *,unsigned int)\n"
	" npstat::ConvolutionEngineND::convolveWithFilter2(double const ,double ,unsigned int const *,unsigned int)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngineND_depositFilter__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngineND arg1 = (npstat::ConvolutionEngineND ) 0 ;
	unsigned long arg2 ;
	float arg3 = (float ) 0 ;
	unsigned int arg4 = (unsigned int ) 0 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:ConvolutionEngineND_depositFilter",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngineND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngineND_depositFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngineND *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngineND * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConvolutionEngineND_depositFilter" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngineND_depositFilter" "', argument " "3"" of type '" "float const *""'");
	}
	arg3 = reinterpret_cast< float * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConvolutionEngineND_depositFilter" "', argument " "4"" of type '" "unsigned int const *""'");
	}
	arg4 = reinterpret_cast< unsigned int * >(argp4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ConvolutionEngineND_depositFilter" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	(arg1)->depositFilter2(arg2,(float const )arg3,(unsigned int const )arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngineND_convolveWithDeposit__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngineND arg1 = (npstat::ConvolutionEngineND ) 0 ;
	unsigned long arg2 ;
	float arg3 = (float ) 0 ;
	float arg4 = (float ) 0 ;
	unsigned int arg5 = (unsigned int ) 0 ;
	unsigned int arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ConvolutionEngineND_convolveWithDeposit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngineND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngineND_convolveWithDeposit" "', argument " "1"" of type '" "npstat::ConvolutionEngineND *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngineND * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConvolutionEngineND_convolveWithDeposit" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngineND_convolveWithDeposit" "', argument " "3"" of type '" "float const *""'");
	}
	arg3 = reinterpret_cast< float * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConvolutionEngineND_convolveWithDeposit" "', argument " "4"" of type '" "float *""'");
	}
	arg4 = reinterpret_cast< float * >(argp4);
	res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ConvolutionEngineND_convolveWithDeposit" "', argument " "5"" of type '" "unsigned int const *""'");
	}
	arg5 = reinterpret_cast< unsigned int * >(argp5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ConvolutionEngineND_convolveWithDeposit" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	{
	try {
	(arg1)->convolveWithDeposit2(arg2,(float const )arg3,arg4,(unsigned int const )arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngineND_depositFilter__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngineND arg1 = (npstat::ConvolutionEngineND ) 0 ;
	unsigned long arg2 ;
	double arg3 = (double ) 0 ;
	unsigned int arg4 = (unsigned int ) 0 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:ConvolutionEngineND_depositFilter",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngineND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngineND_depositFilter" "', argument " "1"" of type '" "npstat::ConvolutionEngineND *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngineND * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConvolutionEngineND_depositFilter" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngineND_depositFilter" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConvolutionEngineND_depositFilter" "', argument " "4"" of type '" "unsigned int const *""'");
	}
	arg4 = reinterpret_cast< unsigned int * >(argp4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ConvolutionEngineND_depositFilter" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	(arg1)->depositFilter2(arg2,(double const )arg3,(unsigned int const )arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngineND_depositFilter(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngineND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngineND_depositFilter__SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngineND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngineND_depositFilter__SWIG_2(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ConvolutionEngineND_depositFilter'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ConvolutionEngineND::depositFilter2(unsigned long,float const ,unsigned int const ,unsigned int)\n"
	" npstat::ConvolutionEngineND::depositFilter2(unsigned long,double const ,unsigned int const ,unsigned int)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngineND_convolveWithDeposit__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ConvolutionEngineND arg1 = (npstat::ConvolutionEngineND ) 0 ;
	unsigned long arg2 ;
	double arg3 = (double ) 0 ;
	double arg4 = (double ) 0 ;
	unsigned int arg5 = (unsigned int ) 0 ;
	unsigned int arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:ConvolutionEngineND_convolveWithDeposit",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__ConvolutionEngineND, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolutionEngineND_convolveWithDeposit" "', argument " "1"" of type '" "npstat::ConvolutionEngineND *""'");
	}
	arg1 = reinterpret_cast< npstat::ConvolutionEngineND * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConvolutionEngineND_convolveWithDeposit" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvolutionEngineND_convolveWithDeposit" "', argument " "3"" of type '" "double const *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConvolutionEngineND_convolveWithDeposit" "', argument " "4"" of type '" "double *""'");
	}
	arg4 = reinterpret_cast< double * >(argp4);
	res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ConvolutionEngineND_convolveWithDeposit" "', argument " "5"" of type '" "unsigned int const *""'");
	}
	arg5 = reinterpret_cast< unsigned int * >(argp5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ConvolutionEngineND_convolveWithDeposit" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	{
	try {
	(arg1)->convolveWithDeposit2(arg2,(double const )arg3,arg4,(unsigned int const )arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_ConvolutionEngineND_convolveWithDeposit(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[7] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 6) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 6) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngineND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_float, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngineND_convolveWithDeposit__SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_npstat__ConvolutionEngineND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_int, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_ConvolutionEngineND_convolveWithDeposit__SWIG_2(self, args);
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'ConvolutionEngineND_convolveWithDeposit'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::ConvolutionEngineND::convolveWithDeposit2(unsigned long,float const ,float ,unsigned int const *,unsigned int)\n"
	" npstat::ConvolutionEngineND::convolveWithDeposit2(unsigned long,double const ,double ,unsigned int const *,unsigned int)\n");
	return 0;
	}


	SWIGINTERN PyObject ConvolutionEngineND_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__ConvolutionEngineND, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_EquidistantInLinearSpace(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	unsigned int arg3 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::EquidistantInLinearSpace *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_EquidistantInLinearSpace",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EquidistantInLinearSpace" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EquidistantInLinearSpace" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EquidistantInLinearSpace" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (npstat::EquidistantInLinearSpace *)new npstat::EquidistantInLinearSpace(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__EquidistantInLinearSpace, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_EquidistantInLinearSpace(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::EquidistantInLinearSpace arg1 = (npstat::EquidistantInLinearSpace ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_EquidistantInLinearSpace",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__EquidistantInLinearSpace, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EquidistantInLinearSpace" "', argument " "1"" of type '" "npstat::EquidistantInLinearSpace *""'");
	}
	arg1 = reinterpret_cast< npstat::EquidistantInLinearSpace * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject EquidistantInLinearSpace_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__EquidistantInLinearSpace, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_EquidistantInLogSpace(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 ;
	double arg2 ;
	unsigned int arg3 ;
	double val1 ;
	int ecode1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	npstat::EquidistantInLogSpace *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_EquidistantInLogSpace",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EquidistantInLogSpace" "', argument " "1"" of type '" "double""'");
	}
	arg1 = static_cast< double >(val1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EquidistantInLogSpace" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EquidistantInLogSpace" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (npstat::EquidistantInLogSpace *)new npstat::EquidistantInLogSpace(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__EquidistantInLogSpace, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_EquidistantInLogSpace(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::EquidistantInLogSpace arg1 = (npstat::EquidistantInLogSpace ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_EquidistantInLogSpace",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__EquidistantInLogSpace, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EquidistantInLogSpace" "', argument " "1"" of type '" "npstat::EquidistantInLogSpace *""'");
	}
	arg1 = reinterpret_cast< npstat::EquidistantInLogSpace * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject EquidistantInLogSpace_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__EquidistantInLogSpace, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_scanKDE1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::KDE1D< double > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	unsigned int arg4 ;
	double arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:scanKDE1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__KDE1DT_double_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scanKDE1D" "', argument " "1"" of type '" "npstat::KDE1D< double > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "scanKDE1D" "', argument " "1"" of type '" "npstat::KDE1D< double > const &""'");
	}
	arg1 = reinterpret_cast< npstat::KDE1D< double > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scanKDE1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "scanKDE1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "scanKDE1D" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "scanKDE1D" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	{
	try {
	result = (PyObject )npstat::scanKDE1D((npstat::KDE1D< double > const &)arg1,arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_variableBandwidthSmooth1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::HistoAxis > *arg1 = 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	double arg4 ;
	bool arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:variableBandwidthSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "variableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "variableBandwidthSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "variableBandwidthSmooth1D" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR variableBandwidthSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >((npstat::HistoND< int,npstat::HistoAxis > const &)arg1,(npstat::AbsDistribution1D const &)*arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_variableBandwidthSmooth1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::HistoAxis > *arg1 = 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:variableBandwidthSmooth1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "variableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "variableBandwidthSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR variableBandwidthSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >((npstat::HistoND< int,npstat::HistoAxis > const &)arg1,(npstat::AbsDistribution1D const &)*arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_variableBandwidthSmooth1D__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::HistoAxis > *arg1 = 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:variableBandwidthSmooth1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "variableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR variableBandwidthSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >((npstat::HistoND< int,npstat::HistoAxis > const &)arg1,(npstat::AbsDistribution1D const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_variableBandwidthSmooth1D__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::HistoAxis > *arg1 = 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	double arg4 ;
	bool arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:variableBandwidthSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "variableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "variableBandwidthSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "variableBandwidthSmooth1D" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR variableBandwidthSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >((npstat::HistoND< long long,npstat::HistoAxis > const &)arg1,(npstat::AbsDistribution1D const &)*arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_variableBandwidthSmooth1D__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::HistoAxis > *arg1 = 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:variableBandwidthSmooth1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "variableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "variableBandwidthSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR variableBandwidthSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >((npstat::HistoND< long long,npstat::HistoAxis > const &)arg1,(npstat::AbsDistribution1D const &)*arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_variableBandwidthSmooth1D__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::HistoAxis > *arg1 = 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:variableBandwidthSmooth1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "variableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR variableBandwidthSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >((npstat::HistoND< long long,npstat::HistoAxis > const &)arg1,(npstat::AbsDistribution1D const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_variableBandwidthSmooth1D__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::HistoAxis > *arg1 = 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	double arg4 ;
	bool arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:variableBandwidthSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "variableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "variableBandwidthSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "variableBandwidthSmooth1D" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR variableBandwidthSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >((npstat::HistoND< float,npstat::HistoAxis > const &)arg1,(npstat::AbsDistribution1D const &)*arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_variableBandwidthSmooth1D__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::HistoAxis > *arg1 = 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:variableBandwidthSmooth1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "variableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "variableBandwidthSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR variableBandwidthSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >((npstat::HistoND< float,npstat::HistoAxis > const &)arg1,(npstat::AbsDistribution1D const &)*arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_variableBandwidthSmooth1D__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::HistoAxis > *arg1 = 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:variableBandwidthSmooth1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "variableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR variableBandwidthSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >((npstat::HistoND< float,npstat::HistoAxis > const &)arg1,(npstat::AbsDistribution1D const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_variableBandwidthSmooth1D__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::HistoAxis > *arg1 = 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	double arg4 ;
	bool arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:variableBandwidthSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "variableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "variableBandwidthSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "variableBandwidthSmooth1D" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR variableBandwidthSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >((npstat::HistoND< double,npstat::HistoAxis > const &)arg1,(npstat::AbsDistribution1D const &)*arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_variableBandwidthSmooth1D__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::HistoAxis > *arg1 = 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:variableBandwidthSmooth1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "variableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "variableBandwidthSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR variableBandwidthSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >((npstat::HistoND< double,npstat::HistoAxis > const &)arg1,(npstat::AbsDistribution1D const &)*arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_variableBandwidthSmooth1D__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::HistoAxis > *arg1 = 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:variableBandwidthSmooth1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "variableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR variableBandwidthSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >((npstat::HistoND< double,npstat::HistoAxis > const &)arg1,(npstat::AbsDistribution1D const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_variableBandwidthSmooth1D__SWIG_12(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::HistoAxis > *arg1 = 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	double arg4 ;
	bool arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	bool val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:variableBandwidthSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "variableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "variableBandwidthSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_bool(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "variableBandwidthSmooth1D" "', argument " "5"" of type '" "bool""'");
	}
	arg5 = static_cast< bool >(val5);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR variableBandwidthSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >((npstat::HistoND< unsigned char,npstat::HistoAxis > const &)arg1,(npstat::AbsDistribution1D const &)*arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_variableBandwidthSmooth1D__SWIG_13(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::HistoAxis > *arg1 = 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:variableBandwidthSmooth1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "variableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "variableBandwidthSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR variableBandwidthSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >((npstat::HistoND< unsigned char,npstat::HistoAxis > const &)arg1,(npstat::AbsDistribution1D const &)*arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_variableBandwidthSmooth1D__SWIG_14(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::HistoAxis > *arg1 = 0 ;
	npstat::AbsDistribution1D *arg2 = 0 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:variableBandwidthSmooth1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::HistoAxis > * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "variableBandwidthSmooth1D" "', argument " "2"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg2 = reinterpret_cast< npstat::AbsDistribution1D * >(argp2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "variableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR variableBandwidthSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >((npstat::HistoND< unsigned char,npstat::HistoAxis > const &)arg1,(npstat::AbsDistribution1D const &)*arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_variableBandwidthSmooth1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_variableBandwidthSmooth1D__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_variableBandwidthSmooth1D__SWIG_5(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_variableBandwidthSmooth1D__SWIG_8(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_variableBandwidthSmooth1D__SWIG_11(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_variableBandwidthSmooth1D__SWIG_14(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_variableBandwidthSmooth1D__SWIG_4(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_variableBandwidthSmooth1D__SWIG_10(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_variableBandwidthSmooth1D__SWIG_1(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_variableBandwidthSmooth1D__SWIG_13(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_variableBandwidthSmooth1D__SWIG_7(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_variableBandwidthSmooth1D__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_variableBandwidthSmooth1D__SWIG_0(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_variableBandwidthSmooth1D__SWIG_12(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_variableBandwidthSmooth1D__SWIG_3(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_variableBandwidthSmooth1D__SWIG_9(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'variableBandwidthSmooth1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::variableBandwidthSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &,npstat::AbsDistribution1D const &,double const,double const,bool const)\n"
	" npstat::variableBandwidthSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &,npstat::AbsDistribution1D const &,double const,double const)\n"
	" npstat::variableBandwidthSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &,npstat::AbsDistribution1D const &,double const)\n"
	" npstat::variableBandwidthSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &,npstat::AbsDistribution1D const &,double const,double const,bool const)\n"
	" npstat::variableBandwidthSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &,npstat::AbsDistribution1D const &,double const,double const)\n"
	" npstat::variableBandwidthSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &,npstat::AbsDistribution1D const &,double const)\n"
	" npstat::variableBandwidthSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &,npstat::AbsDistribution1D const &,double const,double const,bool const)\n"
	" npstat::variableBandwidthSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &,npstat::AbsDistribution1D const &,double const,double const)\n"
	" npstat::variableBandwidthSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &,npstat::AbsDistribution1D const &,double const)\n"
	" npstat::variableBandwidthSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &,npstat::AbsDistribution1D const &,double const,double const,bool const)\n"
	" npstat::variableBandwidthSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &,npstat::AbsDistribution1D const &,double const,double const)\n"
	" npstat::variableBandwidthSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &,npstat::AbsDistribution1D const &,double const)\n"
	" npstat::variableBandwidthSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &,npstat::AbsDistribution1D const &,double const,double const,bool const)\n"
	" npstat::variableBandwidthSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &,npstat::AbsDistribution1D const &,double const,double const)\n"
	" npstat::variableBandwidthSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &,npstat::AbsDistribution1D const &,double const)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_weightedVariableBandwidthSmooth1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:weightedVariableBandwidthSmooth1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >((npstat::HistoND< int,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedVariableBandwidthSmooth1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:weightedVariableBandwidthSmooth1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >((npstat::HistoND< int,npstat::HistoAxis > const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedVariableBandwidthSmooth1D__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:weightedVariableBandwidthSmooth1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >((npstat::HistoND< long long,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedVariableBandwidthSmooth1D__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:weightedVariableBandwidthSmooth1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >((npstat::HistoND< long long,npstat::HistoAxis > const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedVariableBandwidthSmooth1D__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:weightedVariableBandwidthSmooth1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >((npstat::HistoND< float,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedVariableBandwidthSmooth1D__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:weightedVariableBandwidthSmooth1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >((npstat::HistoND< float,npstat::HistoAxis > const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedVariableBandwidthSmooth1D__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:weightedVariableBandwidthSmooth1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >((npstat::HistoND< double,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedVariableBandwidthSmooth1D__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:weightedVariableBandwidthSmooth1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >((npstat::HistoND< double,npstat::HistoAxis > const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedVariableBandwidthSmooth1D__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	double arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:weightedVariableBandwidthSmooth1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >((npstat::HistoND< unsigned char,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedVariableBandwidthSmooth1D__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:weightedVariableBandwidthSmooth1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedVariableBandwidthSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >((npstat::HistoND< unsigned char,npstat::HistoAxis > const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedVariableBandwidthSmooth1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[5] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 4) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_weightedVariableBandwidthSmooth1D__SWIG_1(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_weightedVariableBandwidthSmooth1D__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_weightedVariableBandwidthSmooth1D__SWIG_5(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_weightedVariableBandwidthSmooth1D__SWIG_7(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_weightedVariableBandwidthSmooth1D__SWIG_9(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_weightedVariableBandwidthSmooth1D__SWIG_2(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_weightedVariableBandwidthSmooth1D__SWIG_6(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_weightedVariableBandwidthSmooth1D__SWIG_0(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_weightedVariableBandwidthSmooth1D__SWIG_8(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_weightedVariableBandwidthSmooth1D__SWIG_4(self, args);
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'weightedVariableBandwidthSmooth1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &,double const,int const,double const)\n"
	" npstat::weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &,double const,int const)\n"
	" npstat::weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &,double const,int const,double const)\n"
	" npstat::weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &,double const,int const)\n"
	" npstat::weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &,double const,int const,double const)\n"
	" npstat::weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &,double const,int const)\n"
	" npstat::weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &,double const,int const,double const)\n"
	" npstat::weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &,double const,int const)\n"
	" npstat::weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &,double const,int const,double const)\n"
	" npstat::weightedVariableBandwidthSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &,double const,int const)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_simpleVariableBandwidthSmooth1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:simpleVariableBandwidthSmooth1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >((npstat::HistoND< int,npstat::HistoAxis > const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_simpleVariableBandwidthSmooth1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:simpleVariableBandwidthSmooth1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >((npstat::HistoND< int,npstat::HistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_simpleVariableBandwidthSmooth1D__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:simpleVariableBandwidthSmooth1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >((npstat::HistoND< long long,npstat::HistoAxis > const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_simpleVariableBandwidthSmooth1D__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:simpleVariableBandwidthSmooth1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >((npstat::HistoND< long long,npstat::HistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_simpleVariableBandwidthSmooth1D__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:simpleVariableBandwidthSmooth1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >((npstat::HistoND< float,npstat::HistoAxis > const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_simpleVariableBandwidthSmooth1D__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:simpleVariableBandwidthSmooth1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >((npstat::HistoND< float,npstat::HistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_simpleVariableBandwidthSmooth1D__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:simpleVariableBandwidthSmooth1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >((npstat::HistoND< double,npstat::HistoAxis > const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_simpleVariableBandwidthSmooth1D__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:simpleVariableBandwidthSmooth1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >((npstat::HistoND< double,npstat::HistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_simpleVariableBandwidthSmooth1D__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	double arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:simpleVariableBandwidthSmooth1D",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >((npstat::HistoND< unsigned char,npstat::HistoAxis > const &)arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_simpleVariableBandwidthSmooth1D__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:simpleVariableBandwidthSmooth1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "simpleVariableBandwidthSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >((npstat::HistoND< unsigned char,npstat::HistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_simpleVariableBandwidthSmooth1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_simpleVariableBandwidthSmooth1D__SWIG_1(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_simpleVariableBandwidthSmooth1D__SWIG_3(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_simpleVariableBandwidthSmooth1D__SWIG_5(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_simpleVariableBandwidthSmooth1D__SWIG_7(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_simpleVariableBandwidthSmooth1D__SWIG_9(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_simpleVariableBandwidthSmooth1D__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_simpleVariableBandwidthSmooth1D__SWIG_6(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_simpleVariableBandwidthSmooth1D__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_simpleVariableBandwidthSmooth1D__SWIG_8(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_simpleVariableBandwidthSmooth1D__SWIG_4(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'simpleVariableBandwidthSmooth1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &,int const,double const)\n"
	" npstat::simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &,int const)\n"
	" npstat::simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &,int const,double const)\n"
	" npstat::simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &,int const)\n"
	" npstat::simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &,int const,double const)\n"
	" npstat::simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &,int const)\n"
	" npstat::simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &,int const,double const)\n"
	" npstat::simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &,int const)\n"
	" npstat::simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &,int const,double const)\n"
	" npstat::simpleVariableBandwidthSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &,int const)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_SCharVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< signed char,std::allocator< signed char > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::vector< signed char > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_SCharVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< signed char,std::allocator< signed char > > ptr = (std::vector< signed char,std::allocator< signed char > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_SCharVector" "', argument " "1"" of type '" "std::vector< signed char,std::allocator< signed char > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_SCharVector" "', argument " "1"" of type '" "std::vector< signed char,std::allocator< signed char > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_SCharVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_SCharVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::vector< signed char > > )new gs::ArchiveValueRecord< std::vector< signed char > >((std::vector< signed char,std::allocator< signed char > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_signed_char_std__allocatorT_signed_char_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_SCharVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::vector< signed char > > arg1 = (gs::ArchiveValueRecord< std::vector< signed char > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_SCharVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_signed_char_std__allocatorT_signed_char_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_SCharVector" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::vector< signed char > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::vector< signed char > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_SCharVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_signed_char_std__allocatorT_signed_char_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_SCharVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< signed char,std::allocator< signed char > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::vector< signed char,std::allocator< signed char > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_SCharVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< signed char,std::allocator< signed char > > ptr = (std::vector< signed char,std::allocator< signed char > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_SCharVector" "', argument " "1"" of type '" "std::vector< signed char,std::allocator< signed char > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_SCharVector" "', argument " "1"" of type '" "std::vector< signed char,std::allocator< signed char > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_SCharVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_SCharVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::vector< signed char > >((std::vector< signed char,std::allocator< signed char > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::vector< signed char,std::allocator< signed char > > >(static_cast< const gs::ArchiveValueRecord< std::vector< signed char,std::allocator< signed char > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_signed_char_std__allocatorT_signed_char_t_t_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_SCharVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::vector< signed char > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_SCharVector",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_SCharVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_SCharVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_SCharVector" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::vector< signed char > > )new gs::Reference< std::vector< signed char > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_signed_char_std__allocatorT_signed_char_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_SCharVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< signed char > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_SCharVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_SCharVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_SCharVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_SCharVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_SCharVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::vector< signed char > > )new gs::Reference< std::vector< signed char > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_signed_char_std__allocatorT_signed_char_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_SCharVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< signed char > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_SCharVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_SCharVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_SCharVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_SCharVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_SCharVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_SCharVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_SCharVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::vector< signed char > > )new gs::Reference< std::vector< signed char > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_signed_char_std__allocatorT_signed_char_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_SCharVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_SCharVector__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_SCharVector__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_SCharVector__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_SCharVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::vector< signed char > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::vector< signed char > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::vector< signed char > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_SCharVector_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< signed char > > arg1 = (gs::Reference< std::vector< signed char > > ) 0 ;
	unsigned long arg2 ;
	std::vector< signed char,std::allocator< signed char > > arg3 = (std::vector< signed char,std::allocator< signed char > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_SCharVector_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_signed_char_std__allocatorT_signed_char_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_SCharVector_restore" "', argument " "1"" of type '" "gs::Reference< std::vector< signed char > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< signed char > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_SCharVector_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__vectorT_signed_char_std__allocatorT_signed_char_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_SCharVector_restore" "', argument " "3"" of type '" "std::vector< signed char,std::allocator< signed char > > *""'");
	}
	arg3 = reinterpret_cast< std::vector< signed char,std::allocator< signed char > > * >(argp3);
	{
	try {
	((gs::Reference< std::vector< signed char > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_SCharVector_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< signed char > > arg1 = (gs::Reference< std::vector< signed char > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< signed char,std::allocator< signed char > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_SCharVector_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_signed_char_std__allocatorT_signed_char_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_SCharVector_retrieve" "', argument " "1"" of type '" "gs::Reference< std::vector< signed char > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< signed char > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_SCharVector_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::vector< signed char,std::allocator< signed char > > )gs_Reference_Sl_std_vector_Sl_signed_SS_char_Sg__Sg__retrieve((gs::Reference< std::vector< signed char > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_signed_char_std__allocatorT_signed_char_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_SCharVector_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< signed char > > arg1 = (gs::Reference< std::vector< signed char > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< signed char,std::allocator< signed char > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_SCharVector_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_signed_char_std__allocatorT_signed_char_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_SCharVector_getValue" "', argument " "1"" of type '" "gs::Reference< std::vector< signed char > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< signed char > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_SCharVector_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_vector_Sl_signed_SS_char_Sg__Sg__getValue((gs::Reference< std::vector< signed char > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< signed char,std::allocator< signed char > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_SCharVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< signed char > > arg1 = (gs::Reference< std::vector< signed char > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_SCharVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_signed_char_std__allocatorT_signed_char_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_SCharVector" "', argument " "1"" of type '" "gs::Reference< std::vector< signed char > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< signed char > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_SCharVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__vectorT_signed_char_std__allocatorT_signed_char_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_UCharVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< unsigned char,std::allocator< unsigned char > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::vector< unsigned char > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_UCharVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< unsigned char,std::allocator< unsigned char > > ptr = (std::vector< unsigned char,std::allocator< unsigned char > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_UCharVector" "', argument " "1"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_UCharVector" "', argument " "1"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_UCharVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_UCharVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::vector< unsigned char > > )new gs::ArchiveValueRecord< std::vector< unsigned char > >((std::vector< unsigned char,std::allocator< unsigned char > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_UCharVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::vector< unsigned char > > arg1 = (gs::ArchiveValueRecord< std::vector< unsigned char > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_UCharVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_UCharVector" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::vector< unsigned char > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::vector< unsigned char > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_UCharVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_UCharVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< unsigned char,std::allocator< unsigned char > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::vector< unsigned char,std::allocator< unsigned char > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_UCharVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< unsigned char,std::allocator< unsigned char > > ptr = (std::vector< unsigned char,std::allocator< unsigned char > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_UCharVector" "', argument " "1"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_UCharVector" "', argument " "1"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_UCharVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_UCharVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::vector< unsigned char > >((std::vector< unsigned char,std::allocator< unsigned char > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::vector< unsigned char,std::allocator< unsigned char > > >(static_cast< const gs::ArchiveValueRecord< std::vector< unsigned char,std::allocator< unsigned char > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UCharVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::vector< unsigned char > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_UCharVector",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UCharVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UCharVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_UCharVector" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::vector< unsigned char > > )new gs::Reference< std::vector< unsigned char > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UCharVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< unsigned char > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_UCharVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UCharVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UCharVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_UCharVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_UCharVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::vector< unsigned char > > )new gs::Reference< std::vector< unsigned char > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UCharVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< unsigned char > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_UCharVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UCharVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UCharVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_UCharVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UCharVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_UCharVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UCharVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::vector< unsigned char > > )new gs::Reference< std::vector< unsigned char > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UCharVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_UCharVector__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_UCharVector__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_UCharVector__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_UCharVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::vector< unsigned char > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::vector< unsigned char > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::vector< unsigned char > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_UCharVector_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned char > > arg1 = (gs::Reference< std::vector< unsigned char > > ) 0 ;
	unsigned long arg2 ;
	std::vector< unsigned char,std::allocator< unsigned char > > arg3 = (std::vector< unsigned char,std::allocator< unsigned char > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_UCharVector_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UCharVector_restore" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned char > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned char > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UCharVector_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_UCharVector_restore" "', argument " "3"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > > *""'");
	}
	arg3 = reinterpret_cast< std::vector< unsigned char,std::allocator< unsigned char > > * >(argp3);
	{
	try {
	((gs::Reference< std::vector< unsigned char > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_UCharVector_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned char > > arg1 = (gs::Reference< std::vector< unsigned char > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< unsigned char,std::allocator< unsigned char > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_UCharVector_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UCharVector_retrieve" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned char > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned char > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UCharVector_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::vector< unsigned char,std::allocator< unsigned char > > )gs_Reference_Sl_std_vector_Sl_unsigned_SS_char_Sg__Sg__retrieve((gs::Reference< std::vector< unsigned char > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_UCharVector_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned char > > arg1 = (gs::Reference< std::vector< unsigned char > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< unsigned char,std::allocator< unsigned char > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_UCharVector_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UCharVector_getValue" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned char > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned char > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UCharVector_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_vector_Sl_unsigned_SS_char_Sg__Sg__getValue((gs::Reference< std::vector< unsigned char > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< unsigned char,std::allocator< unsigned char > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_UCharVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned char > > arg1 = (gs::Reference< std::vector< unsigned char > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_UCharVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_UCharVector" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned char > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned char > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_UCharVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_ShortVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< short,std::allocator< short > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::vector< short > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_ShortVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< short,std::allocator< short > > ptr = (std::vector< short,std::allocator< short > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_ShortVector" "', argument " "1"" of type '" "std::vector< short,std::allocator< short > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_ShortVector" "', argument " "1"" of type '" "std::vector< short,std::allocator< short > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_ShortVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_ShortVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::vector< short > > )new gs::ArchiveValueRecord< std::vector< short > >((std::vector< short,std::allocator< short > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_short_std__allocatorT_short_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_ShortVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::vector< short > > arg1 = (gs::ArchiveValueRecord< std::vector< short > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_ShortVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_short_std__allocatorT_short_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_ShortVector" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::vector< short > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::vector< short > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_ShortVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_short_std__allocatorT_short_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_ShortVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< short,std::allocator< short > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::vector< short,std::allocator< short > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_ShortVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< short,std::allocator< short > > ptr = (std::vector< short,std::allocator< short > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_ShortVector" "', argument " "1"" of type '" "std::vector< short,std::allocator< short > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_ShortVector" "', argument " "1"" of type '" "std::vector< short,std::allocator< short > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_ShortVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_ShortVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::vector< short > >((std::vector< short,std::allocator< short > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::vector< short,std::allocator< short > > >(static_cast< const gs::ArchiveValueRecord< std::vector< short,std::allocator< short > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_short_std__allocatorT_short_t_t_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ShortVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::vector< short > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_ShortVector",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_ShortVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ShortVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_ShortVector" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::vector< short > > )new gs::Reference< std::vector< short > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_short_std__allocatorT_short_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ShortVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< short > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_ShortVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_ShortVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ShortVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_ShortVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_ShortVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::vector< short > > )new gs::Reference< std::vector< short > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_short_std__allocatorT_short_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ShortVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< short > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_ShortVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_ShortVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ShortVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_ShortVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ShortVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_ShortVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ShortVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::vector< short > > )new gs::Reference< std::vector< short > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_short_std__allocatorT_short_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ShortVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_ShortVector__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_ShortVector__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_ShortVector__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_ShortVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::vector< short > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::vector< short > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::vector< short > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_ShortVector_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< short > > arg1 = (gs::Reference< std::vector< short > > ) 0 ;
	unsigned long arg2 ;
	std::vector< short,std::allocator< short > > arg3 = (std::vector< short,std::allocator< short > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_ShortVector_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_short_std__allocatorT_short_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_ShortVector_restore" "', argument " "1"" of type '" "gs::Reference< std::vector< short > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< short > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_ShortVector_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_ShortVector_restore" "', argument " "3"" of type '" "std::vector< short,std::allocator< short > > *""'");
	}
	arg3 = reinterpret_cast< std::vector< short,std::allocator< short > > * >(argp3);
	{
	try {
	((gs::Reference< std::vector< short > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_ShortVector_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< short > > arg1 = (gs::Reference< std::vector< short > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< short,std::allocator< short > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_ShortVector_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_short_std__allocatorT_short_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_ShortVector_retrieve" "', argument " "1"" of type '" "gs::Reference< std::vector< short > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< short > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_ShortVector_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::vector< short,std::allocator< short > > )gs_Reference_Sl_std_vector_Sl_short_Sg__Sg__retrieve((gs::Reference< std::vector< short > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_ShortVector_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< short > > arg1 = (gs::Reference< std::vector< short > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< short,std::allocator< short > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_ShortVector_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_short_std__allocatorT_short_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_ShortVector_getValue" "', argument " "1"" of type '" "gs::Reference< std::vector< short > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< short > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_ShortVector_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_vector_Sl_short_Sg__Sg__getValue((gs::Reference< std::vector< short > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< short,std::allocator< short > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_ShortVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< short > > arg1 = (gs::Reference< std::vector< short > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_ShortVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_short_std__allocatorT_short_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_ShortVector" "', argument " "1"" of type '" "gs::Reference< std::vector< short > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< short > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_ShortVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__vectorT_short_std__allocatorT_short_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_UShortVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< unsigned short,std::allocator< unsigned short > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::vector< unsigned short > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_UShortVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< unsigned short,std::allocator< unsigned short > > ptr = (std::vector< unsigned short,std::allocator< unsigned short > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_UShortVector" "', argument " "1"" of type '" "std::vector< unsigned short,std::allocator< unsigned short > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_UShortVector" "', argument " "1"" of type '" "std::vector< unsigned short,std::allocator< unsigned short > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_UShortVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_UShortVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::vector< unsigned short > > )new gs::ArchiveValueRecord< std::vector< unsigned short > >((std::vector< unsigned short,std::allocator< unsigned short > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_UShortVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::vector< unsigned short > > arg1 = (gs::ArchiveValueRecord< std::vector< unsigned short > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_UShortVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_UShortVector" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::vector< unsigned short > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::vector< unsigned short > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_UShortVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_UShortVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< unsigned short,std::allocator< unsigned short > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::vector< unsigned short,std::allocator< unsigned short > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_UShortVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< unsigned short,std::allocator< unsigned short > > ptr = (std::vector< unsigned short,std::allocator< unsigned short > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_UShortVector" "', argument " "1"" of type '" "std::vector< unsigned short,std::allocator< unsigned short > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_UShortVector" "', argument " "1"" of type '" "std::vector< unsigned short,std::allocator< unsigned short > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_UShortVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_UShortVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::vector< unsigned short > >((std::vector< unsigned short,std::allocator< unsigned short > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::vector< unsigned short,std::allocator< unsigned short > > >(static_cast< const gs::ArchiveValueRecord< std::vector< unsigned short,std::allocator< unsigned short > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UShortVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::vector< unsigned short > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_UShortVector",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UShortVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UShortVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_UShortVector" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::vector< unsigned short > > )new gs::Reference< std::vector< unsigned short > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UShortVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< unsigned short > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_UShortVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UShortVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UShortVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_UShortVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_UShortVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::vector< unsigned short > > )new gs::Reference< std::vector< unsigned short > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UShortVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< unsigned short > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_UShortVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UShortVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UShortVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_UShortVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UShortVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_UShortVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UShortVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::vector< unsigned short > > )new gs::Reference< std::vector< unsigned short > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UShortVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_UShortVector__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_UShortVector__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_UShortVector__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_UShortVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::vector< unsigned short > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::vector< unsigned short > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::vector< unsigned short > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_UShortVector_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned short > > arg1 = (gs::Reference< std::vector< unsigned short > > ) 0 ;
	unsigned long arg2 ;
	std::vector< unsigned short,std::allocator< unsigned short > > arg3 = (std::vector< unsigned short,std::allocator< unsigned short > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_UShortVector_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UShortVector_restore" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned short > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned short > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UShortVector_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_UShortVector_restore" "', argument " "3"" of type '" "std::vector< unsigned short,std::allocator< unsigned short > > *""'");
	}
	arg3 = reinterpret_cast< std::vector< unsigned short,std::allocator< unsigned short > > * >(argp3);
	{
	try {
	((gs::Reference< std::vector< unsigned short > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_UShortVector_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned short > > arg1 = (gs::Reference< std::vector< unsigned short > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< unsigned short,std::allocator< unsigned short > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_UShortVector_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UShortVector_retrieve" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned short > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned short > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UShortVector_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::vector< unsigned short,std::allocator< unsigned short > > )gs_Reference_Sl_std_vector_Sl_unsigned_SS_short_Sg__Sg__retrieve((gs::Reference< std::vector< unsigned short > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_UShortVector_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned short > > arg1 = (gs::Reference< std::vector< unsigned short > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< unsigned short,std::allocator< unsigned short > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_UShortVector_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UShortVector_getValue" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned short > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned short > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UShortVector_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_vector_Sl_unsigned_SS_short_Sg__Sg__getValue((gs::Reference< std::vector< unsigned short > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< unsigned short,std::allocator< unsigned short > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_UShortVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned short > > arg1 = (gs::Reference< std::vector< unsigned short > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_UShortVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_UShortVector" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned short > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned short > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_UShortVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_short_std__allocatorT_unsigned_short_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_LongVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< long,std::allocator< long > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::vector< long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_LongVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< long,std::allocator< long > > ptr = (std::vector< long,std::allocator< long > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_LongVector" "', argument " "1"" of type '" "std::vector< long,std::allocator< long > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_LongVector" "', argument " "1"" of type '" "std::vector< long,std::allocator< long > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_LongVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_LongVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::vector< long > > )new gs::ArchiveValueRecord< std::vector< long > >((std::vector< long,std::allocator< long > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_long_std__allocatorT_long_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_LongVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::vector< long > > arg1 = (gs::ArchiveValueRecord< std::vector< long > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_LongVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_long_std__allocatorT_long_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_LongVector" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::vector< long > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::vector< long > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_LongVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_long_std__allocatorT_long_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_LongVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< long,std::allocator< long > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::vector< long,std::allocator< long > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_LongVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< long,std::allocator< long > > ptr = (std::vector< long,std::allocator< long > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_LongVector" "', argument " "1"" of type '" "std::vector< long,std::allocator< long > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_LongVector" "', argument " "1"" of type '" "std::vector< long,std::allocator< long > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_LongVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_LongVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::vector< long > >((std::vector< long,std::allocator< long > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::vector< long,std::allocator< long > > >(static_cast< const gs::ArchiveValueRecord< std::vector< long,std::allocator< long > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_long_std__allocatorT_long_t_t_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LongVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::vector< long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_LongVector",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_LongVector" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::vector< long > > )new gs::Reference< std::vector< long > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_std__allocatorT_long_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LongVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_LongVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_LongVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_LongVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::vector< long > > )new gs::Reference< std::vector< long > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_std__allocatorT_long_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LongVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_LongVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_LongVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LongVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_LongVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LongVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::vector< long > > )new gs::Reference< std::vector< long > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_std__allocatorT_long_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LongVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_LongVector__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_LongVector__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_LongVector__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_LongVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::vector< long > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::vector< long > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::vector< long > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_LongVector_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< long > > arg1 = (gs::Reference< std::vector< long > > ) 0 ;
	unsigned long arg2 ;
	std::vector< long,std::allocator< long > > arg3 = (std::vector< long,std::allocator< long > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_LongVector_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_std__allocatorT_long_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LongVector_restore" "', argument " "1"" of type '" "gs::Reference< std::vector< long > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< long > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LongVector_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_LongVector_restore" "', argument " "3"" of type '" "std::vector< long,std::allocator< long > > *""'");
	}
	arg3 = reinterpret_cast< std::vector< long,std::allocator< long > > * >(argp3);
	{
	try {
	((gs::Reference< std::vector< long > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_LongVector_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< long > > arg1 = (gs::Reference< std::vector< long > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< long,std::allocator< long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_LongVector_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_std__allocatorT_long_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LongVector_retrieve" "', argument " "1"" of type '" "gs::Reference< std::vector< long > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< long > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LongVector_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::vector< long,std::allocator< long > > )gs_Reference_Sl_std_vector_Sl_long_Sg__Sg__retrieve((gs::Reference< std::vector< long > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_LongVector_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< long > > arg1 = (gs::Reference< std::vector< long > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< long,std::allocator< long > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_LongVector_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_std__allocatorT_long_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LongVector_getValue" "', argument " "1"" of type '" "gs::Reference< std::vector< long > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< long > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LongVector_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_vector_Sl_long_Sg__Sg__getValue((gs::Reference< std::vector< long > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< long,std::allocator< long > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_LongVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< long > > arg1 = (gs::Reference< std::vector< long > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_LongVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_std__allocatorT_long_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_LongVector" "', argument " "1"" of type '" "gs::Reference< std::vector< long > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< long > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_LongVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_std__allocatorT_long_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_ULongVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< unsigned long,std::allocator< unsigned long > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::vector< unsigned long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_ULongVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< unsigned long,std::allocator< unsigned long > > ptr = (std::vector< unsigned long,std::allocator< unsigned long > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_ULongVector" "', argument " "1"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_ULongVector" "', argument " "1"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_ULongVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_ULongVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::vector< unsigned long > > )new gs::ArchiveValueRecord< std::vector< unsigned long > >((std::vector< unsigned long,std::allocator< unsigned long > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_ULongVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::vector< unsigned long > > arg1 = (gs::ArchiveValueRecord< std::vector< unsigned long > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_ULongVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_ULongVector" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::vector< unsigned long > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::vector< unsigned long > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_ULongVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_ULongVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< unsigned long,std::allocator< unsigned long > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::vector< unsigned long,std::allocator< unsigned long > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_ULongVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< unsigned long,std::allocator< unsigned long > > ptr = (std::vector< unsigned long,std::allocator< unsigned long > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_ULongVector" "', argument " "1"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_ULongVector" "', argument " "1"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_ULongVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_ULongVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::vector< unsigned long > >((std::vector< unsigned long,std::allocator< unsigned long > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::vector< unsigned long,std::allocator< unsigned long > > >(static_cast< const gs::ArchiveValueRecord< std::vector< unsigned long,std::allocator< unsigned long > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ULongVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::vector< unsigned long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_ULongVector",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_ULongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_ULongVector" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::vector< unsigned long > > )new gs::Reference< std::vector< unsigned long > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ULongVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< unsigned long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_ULongVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_ULongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_ULongVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_ULongVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::vector< unsigned long > > )new gs::Reference< std::vector< unsigned long > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ULongVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< unsigned long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_ULongVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_ULongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_ULongVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULongVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_ULongVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULongVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::vector< unsigned long > > )new gs::Reference< std::vector< unsigned long > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ULongVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_ULongVector__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_ULongVector__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_ULongVector__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_ULongVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::vector< unsigned long > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::vector< unsigned long > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::vector< unsigned long > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_ULongVector_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned long > > arg1 = (gs::Reference< std::vector< unsigned long > > ) 0 ;
	unsigned long arg2 ;
	std::vector< unsigned long,std::allocator< unsigned long > > arg3 = (std::vector< unsigned long,std::allocator< unsigned long > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_ULongVector_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_ULongVector_restore" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned long > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned long > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_ULongVector_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_ULongVector_restore" "', argument " "3"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > *""'");
	}
	arg3 = reinterpret_cast< std::vector< unsigned long,std::allocator< unsigned long > > * >(argp3);
	{
	try {
	((gs::Reference< std::vector< unsigned long > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_ULongVector_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned long > > arg1 = (gs::Reference< std::vector< unsigned long > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< unsigned long,std::allocator< unsigned long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_ULongVector_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_ULongVector_retrieve" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned long > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned long > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_ULongVector_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::vector< unsigned long,std::allocator< unsigned long > > )gs_Reference_Sl_std_vector_Sl_unsigned_SS_long_Sg__Sg__retrieve((gs::Reference< std::vector< unsigned long > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_ULongVector_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned long > > arg1 = (gs::Reference< std::vector< unsigned long > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< unsigned long,std::allocator< unsigned long > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_ULongVector_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_ULongVector_getValue" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned long > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned long > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_ULongVector_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_vector_Sl_unsigned_SS_long_Sg__Sg__getValue((gs::Reference< std::vector< unsigned long > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< unsigned long,std::allocator< unsigned long > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_ULongVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned long > > arg1 = (gs::Reference< std::vector< unsigned long > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_ULongVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_ULongVector" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned long > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned long > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_ULongVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_IntVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< int,std::allocator< int > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::vector< int > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_IntVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< int,std::allocator< int > > ptr = (std::vector< int,std::allocator< int > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_IntVector" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_IntVector" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_IntVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_IntVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::vector< int > > )new gs::ArchiveValueRecord< std::vector< int > >((std::vector< int,std::allocator< int > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_int_std__allocatorT_int_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_IntVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::vector< int > > arg1 = (gs::ArchiveValueRecord< std::vector< int > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_IntVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_int_std__allocatorT_int_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_IntVector" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::vector< int > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::vector< int > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_IntVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_int_std__allocatorT_int_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_IntVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< int,std::allocator< int > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::vector< int,std::allocator< int > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_IntVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< int,std::allocator< int > > ptr = (std::vector< int,std::allocator< int > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_IntVector" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_IntVector" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_IntVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_IntVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::vector< int > >((std::vector< int,std::allocator< int > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::vector< int,std::allocator< int > > >(static_cast< const gs::ArchiveValueRecord< std::vector< int,std::allocator< int > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_int_std__allocatorT_int_t_t_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_IntVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::vector< int > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_IntVector",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_IntVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_IntVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_IntVector" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::vector< int > > )new gs::Reference< std::vector< int > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_int_std__allocatorT_int_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_IntVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< int > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_IntVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_IntVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_IntVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_IntVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_IntVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::vector< int > > )new gs::Reference< std::vector< int > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_int_std__allocatorT_int_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_IntVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< int > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_IntVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_IntVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_IntVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_IntVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_IntVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_IntVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_IntVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::vector< int > > )new gs::Reference< std::vector< int > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_int_std__allocatorT_int_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_IntVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_IntVector__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_IntVector__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_IntVector__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_IntVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::vector< int > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::vector< int > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::vector< int > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_IntVector_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< int > > arg1 = (gs::Reference< std::vector< int > > ) 0 ;
	unsigned long arg2 ;
	std::vector< int,std::allocator< int > > arg3 = (std::vector< int,std::allocator< int > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_IntVector_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_int_std__allocatorT_int_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_IntVector_restore" "', argument " "1"" of type '" "gs::Reference< std::vector< int > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< int > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_IntVector_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_IntVector_restore" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > *""'");
	}
	arg3 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp3);
	{
	try {
	((gs::Reference< std::vector< int > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_IntVector_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< int > > arg1 = (gs::Reference< std::vector< int > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< int,std::allocator< int > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_IntVector_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_int_std__allocatorT_int_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_IntVector_retrieve" "', argument " "1"" of type '" "gs::Reference< std::vector< int > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< int > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_IntVector_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::vector< int,std::allocator< int > > )gs_Reference_Sl_std_vector_Sl_int_Sg__Sg__retrieve((gs::Reference< std::vector< int > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_IntVector_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< int > > arg1 = (gs::Reference< std::vector< int > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< int,std::allocator< int > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_IntVector_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_int_std__allocatorT_int_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_IntVector_getValue" "', argument " "1"" of type '" "gs::Reference< std::vector< int > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< int > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_IntVector_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_vector_Sl_int_Sg__Sg__getValue((gs::Reference< std::vector< int > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_IntVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< int > > arg1 = (gs::Reference< std::vector< int > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_IntVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_int_std__allocatorT_int_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_IntVector" "', argument " "1"" of type '" "gs::Reference< std::vector< int > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< int > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_IntVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__vectorT_int_std__allocatorT_int_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_LLongVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< long long,std::allocator< long long > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::vector< long long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_LLongVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< long long,std::allocator< long long > > ptr = (std::vector< long long,std::allocator< long long > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_LLongVector" "', argument " "1"" of type '" "std::vector< long long,std::allocator< long long > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_LLongVector" "', argument " "1"" of type '" "std::vector< long long,std::allocator< long long > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_LLongVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_LLongVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::vector< long long > > )new gs::ArchiveValueRecord< std::vector< long long > >((std::vector< long long,std::allocator< long long > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_long_long_std__allocatorT_long_long_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_LLongVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::vector< long long > > arg1 = (gs::ArchiveValueRecord< std::vector< long long > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_LLongVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_long_long_std__allocatorT_long_long_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_LLongVector" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::vector< long long > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::vector< long long > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_LLongVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_long_long_std__allocatorT_long_long_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_LLongVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< long long,std::allocator< long long > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::vector< long long,std::allocator< long long > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_LLongVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< long long,std::allocator< long long > > ptr = (std::vector< long long,std::allocator< long long > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_LLongVector" "', argument " "1"" of type '" "std::vector< long long,std::allocator< long long > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_LLongVector" "', argument " "1"" of type '" "std::vector< long long,std::allocator< long long > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_LLongVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_LLongVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::vector< long long > >((std::vector< long long,std::allocator< long long > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::vector< long long,std::allocator< long long > > >(static_cast< const gs::ArchiveValueRecord< std::vector< long long,std::allocator< long long > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_long_long_std__allocatorT_long_long_t_t_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LLongVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::vector< long long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_LLongVector",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LLongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LLongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_LLongVector" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::vector< long long > > )new gs::Reference< std::vector< long long > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_long_std__allocatorT_long_long_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LLongVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< long long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_LLongVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LLongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LLongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_LLongVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_LLongVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::vector< long long > > )new gs::Reference< std::vector< long long > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_long_std__allocatorT_long_long_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LLongVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< long long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_LLongVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LLongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LLongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_LLongVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LLongVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_LLongVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LLongVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::vector< long long > > )new gs::Reference< std::vector< long long > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_long_std__allocatorT_long_long_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LLongVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_LLongVector__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_LLongVector__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_LLongVector__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_LLongVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::vector< long long > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::vector< long long > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::vector< long long > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_LLongVector_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< long long > > arg1 = (gs::Reference< std::vector< long long > > ) 0 ;
	unsigned long arg2 ;
	std::vector< long long,std::allocator< long long > > arg3 = (std::vector< long long,std::allocator< long long > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_LLongVector_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_long_std__allocatorT_long_long_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LLongVector_restore" "', argument " "1"" of type '" "gs::Reference< std::vector< long long > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< long long > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LLongVector_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__vectorT_long_long_std__allocatorT_long_long_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_LLongVector_restore" "', argument " "3"" of type '" "std::vector< long long,std::allocator< long long > > *""'");
	}
	arg3 = reinterpret_cast< std::vector< long long,std::allocator< long long > > * >(argp3);
	{
	try {
	((gs::Reference< std::vector< long long > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_LLongVector_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< long long > > arg1 = (gs::Reference< std::vector< long long > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< long long,std::allocator< long long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_LLongVector_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_long_std__allocatorT_long_long_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LLongVector_retrieve" "', argument " "1"" of type '" "gs::Reference< std::vector< long long > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< long long > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LLongVector_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::vector< long long,std::allocator< long long > > )gs_Reference_Sl_std_vector_Sl_long_SS_long_Sg__Sg__retrieve((gs::Reference< std::vector< long long > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_long_std__allocatorT_long_long_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_LLongVector_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< long long > > arg1 = (gs::Reference< std::vector< long long > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< long long,std::allocator< long long > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_LLongVector_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_long_std__allocatorT_long_long_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LLongVector_getValue" "', argument " "1"" of type '" "gs::Reference< std::vector< long long > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< long long > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LLongVector_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_vector_Sl_long_SS_long_Sg__Sg__getValue((gs::Reference< std::vector< long long > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< long long,std::allocator< long long > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_LLongVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< long long > > arg1 = (gs::Reference< std::vector< long long > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_LLongVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_long_std__allocatorT_long_long_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_LLongVector" "', argument " "1"" of type '" "gs::Reference< std::vector< long long > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< long long > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_LLongVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_long_std__allocatorT_long_long_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_UIntVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< unsigned int,std::allocator< unsigned int > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::vector< unsigned int > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_UIntVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< unsigned int,std::allocator< unsigned int > > ptr = (std::vector< unsigned int,std::allocator< unsigned int > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_UIntVector" "', argument " "1"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_UIntVector" "', argument " "1"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_UIntVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_UIntVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::vector< unsigned int > > )new gs::ArchiveValueRecord< std::vector< unsigned int > >((std::vector< unsigned int,std::allocator< unsigned int > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_UIntVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::vector< unsigned int > > arg1 = (gs::ArchiveValueRecord< std::vector< unsigned int > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_UIntVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_UIntVector" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::vector< unsigned int > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::vector< unsigned int > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_UIntVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_UIntVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< unsigned int,std::allocator< unsigned int > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::vector< unsigned int,std::allocator< unsigned int > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_UIntVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< unsigned int,std::allocator< unsigned int > > ptr = (std::vector< unsigned int,std::allocator< unsigned int > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_UIntVector" "', argument " "1"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_UIntVector" "', argument " "1"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_UIntVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_UIntVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::vector< unsigned int > >((std::vector< unsigned int,std::allocator< unsigned int > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::vector< unsigned int,std::allocator< unsigned int > > >(static_cast< const gs::ArchiveValueRecord< std::vector< unsigned int,std::allocator< unsigned int > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UIntVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::vector< unsigned int > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_UIntVector",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UIntVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UIntVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_UIntVector" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::vector< unsigned int > > )new gs::Reference< std::vector< unsigned int > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UIntVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< unsigned int > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_UIntVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UIntVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UIntVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_UIntVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_UIntVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::vector< unsigned int > > )new gs::Reference< std::vector< unsigned int > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UIntVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< unsigned int > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_UIntVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UIntVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UIntVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_UIntVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UIntVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_UIntVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UIntVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::vector< unsigned int > > )new gs::Reference< std::vector< unsigned int > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UIntVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_UIntVector__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_UIntVector__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_UIntVector__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_UIntVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::vector< unsigned int > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::vector< unsigned int > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::vector< unsigned int > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_UIntVector_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned int > > arg1 = (gs::Reference< std::vector< unsigned int > > ) 0 ;
	unsigned long arg2 ;
	std::vector< unsigned int,std::allocator< unsigned int > > arg3 = (std::vector< unsigned int,std::allocator< unsigned int > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_UIntVector_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UIntVector_restore" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned int > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned int > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UIntVector_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_UIntVector_restore" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > *""'");
	}
	arg3 = reinterpret_cast< std::vector< unsigned int,std::allocator< unsigned int > > * >(argp3);
	{
	try {
	((gs::Reference< std::vector< unsigned int > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_UIntVector_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned int > > arg1 = (gs::Reference< std::vector< unsigned int > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_UIntVector_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UIntVector_retrieve" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned int > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned int > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UIntVector_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::vector< unsigned int,std::allocator< unsigned int > > )gs_Reference_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__retrieve((gs::Reference< std::vector< unsigned int > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_UIntVector_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned int > > arg1 = (gs::Reference< std::vector< unsigned int > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< unsigned int,std::allocator< unsigned int > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_UIntVector_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UIntVector_getValue" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned int > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned int > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UIntVector_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__getValue((gs::Reference< std::vector< unsigned int > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_UIntVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned int > > arg1 = (gs::Reference< std::vector< unsigned int > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_UIntVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_UIntVector" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned int > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned int > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_UIntVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_ULLongVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< unsigned long long,std::allocator< unsigned long long > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::vector< unsigned long long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_ULLongVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< unsigned long long,std::allocator< unsigned long long > > ptr = (std::vector< unsigned long long,std::allocator< unsigned long long > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_ULLongVector" "', argument " "1"" of type '" "std::vector< unsigned long long,std::allocator< unsigned long long > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_ULLongVector" "', argument " "1"" of type '" "std::vector< unsigned long long,std::allocator< unsigned long long > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_ULLongVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_ULLongVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::vector< unsigned long long > > )new gs::ArchiveValueRecord< std::vector< unsigned long long > >((std::vector< unsigned long long,std::allocator< unsigned long long > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_long_long_std__allocatorT_unsigned_long_long_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_ULLongVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::vector< unsigned long long > > arg1 = (gs::ArchiveValueRecord< std::vector< unsigned long long > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_ULLongVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_long_long_std__allocatorT_unsigned_long_long_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_ULLongVector" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::vector< unsigned long long > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::vector< unsigned long long > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_ULLongVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_long_long_std__allocatorT_unsigned_long_long_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_ULLongVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< unsigned long long,std::allocator< unsigned long long > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::vector< unsigned long long,std::allocator< unsigned long long > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_ULLongVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< unsigned long long,std::allocator< unsigned long long > > ptr = (std::vector< unsigned long long,std::allocator< unsigned long long > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_ULLongVector" "', argument " "1"" of type '" "std::vector< unsigned long long,std::allocator< unsigned long long > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_ULLongVector" "', argument " "1"" of type '" "std::vector< unsigned long long,std::allocator< unsigned long long > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_ULLongVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_ULLongVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::vector< unsigned long long > >((std::vector< unsigned long long,std::allocator< unsigned long long > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::vector< unsigned long long,std::allocator< unsigned long long > > >(static_cast< const gs::ArchiveValueRecord< std::vector< unsigned long long,std::allocator< unsigned long long > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_unsigned_long_long_std__allocatorT_unsigned_long_long_t_t_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ULLongVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::vector< unsigned long long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_ULLongVector",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_ULLongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULLongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_ULLongVector" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::vector< unsigned long long > > )new gs::Reference< std::vector< unsigned long long > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_long_long_std__allocatorT_unsigned_long_long_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ULLongVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< unsigned long long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_ULLongVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_ULLongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULLongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_ULLongVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_ULLongVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::vector< unsigned long long > > )new gs::Reference< std::vector< unsigned long long > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_long_long_std__allocatorT_unsigned_long_long_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ULLongVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< unsigned long long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_ULLongVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_ULLongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULLongVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_ULLongVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULLongVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_ULLongVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULLongVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::vector< unsigned long long > > )new gs::Reference< std::vector< unsigned long long > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_long_long_std__allocatorT_unsigned_long_long_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ULLongVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_ULLongVector__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_ULLongVector__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_ULLongVector__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_ULLongVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::vector< unsigned long long > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::vector< unsigned long long > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::vector< unsigned long long > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_ULLongVector_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned long long > > arg1 = (gs::Reference< std::vector< unsigned long long > > ) 0 ;
	unsigned long arg2 ;
	std::vector< unsigned long long,std::allocator< unsigned long long > > arg3 = (std::vector< unsigned long long,std::allocator< unsigned long long > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_ULLongVector_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_long_long_std__allocatorT_unsigned_long_long_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_ULLongVector_restore" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned long long > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned long long > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_ULLongVector_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__vectorT_unsigned_long_long_std__allocatorT_unsigned_long_long_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_ULLongVector_restore" "', argument " "3"" of type '" "std::vector< unsigned long long,std::allocator< unsigned long long > > *""'");
	}
	arg3 = reinterpret_cast< std::vector< unsigned long long,std::allocator< unsigned long long > > * >(argp3);
	{
	try {
	((gs::Reference< std::vector< unsigned long long > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_ULLongVector_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned long long > > arg1 = (gs::Reference< std::vector< unsigned long long > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< unsigned long long,std::allocator< unsigned long long > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_ULLongVector_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_long_long_std__allocatorT_unsigned_long_long_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_ULLongVector_retrieve" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned long long > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned long long > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_ULLongVector_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::vector< unsigned long long,std::allocator< unsigned long long > > )gs_Reference_Sl_std_vector_Sl_unsigned_SS_long_SS_long_Sg__Sg__retrieve((gs::Reference< std::vector< unsigned long long > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_long_long_std__allocatorT_unsigned_long_long_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_ULLongVector_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned long long > > arg1 = (gs::Reference< std::vector< unsigned long long > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< unsigned long long,std::allocator< unsigned long long > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_ULLongVector_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_long_long_std__allocatorT_unsigned_long_long_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_ULLongVector_getValue" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned long long > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned long long > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_ULLongVector_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_vector_Sl_unsigned_SS_long_SS_long_Sg__Sg__getValue((gs::Reference< std::vector< unsigned long long > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< unsigned long long,std::allocator< unsigned long long > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_ULLongVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< unsigned long long > > arg1 = (gs::Reference< std::vector< unsigned long long > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_ULLongVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_long_long_std__allocatorT_unsigned_long_long_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_ULLongVector" "', argument " "1"" of type '" "gs::Reference< std::vector< unsigned long long > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< unsigned long long > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_ULLongVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__vectorT_unsigned_long_long_std__allocatorT_unsigned_long_long_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_FloatVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< float,std::allocator< float > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::vector< float > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_FloatVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< float,std::allocator< float > > ptr = (std::vector< float,std::allocator< float > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_FloatVector" "', argument " "1"" of type '" "std::vector< float,std::allocator< float > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_FloatVector" "', argument " "1"" of type '" "std::vector< float,std::allocator< float > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_FloatVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_FloatVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::vector< float > > )new gs::ArchiveValueRecord< std::vector< float > >((std::vector< float,std::allocator< float > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_float_std__allocatorT_float_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_FloatVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::vector< float > > arg1 = (gs::ArchiveValueRecord< std::vector< float > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_FloatVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_float_std__allocatorT_float_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_FloatVector" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::vector< float > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::vector< float > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_FloatVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_float_std__allocatorT_float_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_FloatVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< float,std::allocator< float > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::vector< float,std::allocator< float > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_FloatVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< float,std::allocator< float > > ptr = (std::vector< float,std::allocator< float > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_FloatVector" "', argument " "1"" of type '" "std::vector< float,std::allocator< float > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_FloatVector" "', argument " "1"" of type '" "std::vector< float,std::allocator< float > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_FloatVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_FloatVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::vector< float > >((std::vector< float,std::allocator< float > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::vector< float,std::allocator< float > > >(static_cast< const gs::ArchiveValueRecord< std::vector< float,std::allocator< float > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_float_std__allocatorT_float_t_t_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_FloatVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::vector< float > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_FloatVector",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_FloatVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_FloatVector" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::vector< float > > )new gs::Reference< std::vector< float > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_float_std__allocatorT_float_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_FloatVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< float > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_FloatVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_FloatVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_FloatVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_FloatVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::vector< float > > )new gs::Reference< std::vector< float > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_float_std__allocatorT_float_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_FloatVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< float > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_FloatVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_FloatVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_FloatVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_FloatVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_FloatVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::vector< float > > )new gs::Reference< std::vector< float > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_float_std__allocatorT_float_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_FloatVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_FloatVector__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_FloatVector__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_FloatVector__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_FloatVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::vector< float > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::vector< float > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::vector< float > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_FloatVector_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< float > > arg1 = (gs::Reference< std::vector< float > > ) 0 ;
	unsigned long arg2 ;
	std::vector< float,std::allocator< float > > arg3 = (std::vector< float,std::allocator< float > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_FloatVector_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_float_std__allocatorT_float_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_FloatVector_restore" "', argument " "1"" of type '" "gs::Reference< std::vector< float > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< float > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_FloatVector_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_FloatVector_restore" "', argument " "3"" of type '" "std::vector< float,std::allocator< float > > *""'");
	}
	arg3 = reinterpret_cast< std::vector< float,std::allocator< float > > * >(argp3);
	{
	try {
	((gs::Reference< std::vector< float > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_FloatVector_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< float > > arg1 = (gs::Reference< std::vector< float > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< float,std::allocator< float > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_FloatVector_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_float_std__allocatorT_float_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_FloatVector_retrieve" "', argument " "1"" of type '" "gs::Reference< std::vector< float > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< float > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_FloatVector_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::vector< float,std::allocator< float > > )gs_Reference_Sl_std_vector_Sl_float_Sg__Sg__retrieve((gs::Reference< std::vector< float > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_float_std__allocatorT_float_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_FloatVector_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< float > > arg1 = (gs::Reference< std::vector< float > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< float,std::allocator< float > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_FloatVector_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_float_std__allocatorT_float_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_FloatVector_getValue" "', argument " "1"" of type '" "gs::Reference< std::vector< float > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< float > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_FloatVector_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_vector_Sl_float_Sg__Sg__getValue((gs::Reference< std::vector< float > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< float,std::allocator< float > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_FloatVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< float > > arg1 = (gs::Reference< std::vector< float > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_FloatVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_float_std__allocatorT_float_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_FloatVector" "', argument " "1"" of type '" "gs::Reference< std::vector< float > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< float > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_FloatVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__vectorT_float_std__allocatorT_float_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_DoubleVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< double,std::allocator< double > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::vector< double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_DoubleVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_DoubleVector" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_DoubleVector" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_DoubleVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_DoubleVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::vector< double > > )new gs::ArchiveValueRecord< std::vector< double > >((std::vector< double,std::allocator< double > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_DoubleVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::vector< double > > arg1 = (gs::ArchiveValueRecord< std::vector< double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_DoubleVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_DoubleVector" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::vector< double > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::vector< double > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_DoubleVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_DoubleVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< double,std::allocator< double > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::vector< double,std::allocator< double > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_DoubleVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_DoubleVector" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_DoubleVector" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_DoubleVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_DoubleVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::vector< double > >((std::vector< double,std::allocator< double > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::vector< double,std::allocator< double > > >(static_cast< const gs::ArchiveValueRecord< std::vector< double,std::allocator< double > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DoubleVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::vector< double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_DoubleVector",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_DoubleVector" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::vector< double > > )new gs::Reference< std::vector< double > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DoubleVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_DoubleVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_DoubleVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_DoubleVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::vector< double > > )new gs::Reference< std::vector< double > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DoubleVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_DoubleVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_DoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_DoubleVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_DoubleVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_DoubleVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::vector< double > > )new gs::Reference< std::vector< double > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_DoubleVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_DoubleVector__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_DoubleVector__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_DoubleVector__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_DoubleVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::vector< double > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::vector< double > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::vector< double > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_DoubleVector_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< double > > arg1 = (gs::Reference< std::vector< double > > ) 0 ;
	unsigned long arg2 ;
	std::vector< double,std::allocator< double > > arg3 = (std::vector< double,std::allocator< double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_DoubleVector_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_DoubleVector_restore" "', argument " "1"" of type '" "gs::Reference< std::vector< double > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< double > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_DoubleVector_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_DoubleVector_restore" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > *""'");
	}
	arg3 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp3);
	{
	try {
	((gs::Reference< std::vector< double > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_DoubleVector_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< double > > arg1 = (gs::Reference< std::vector< double > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< double,std::allocator< double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_DoubleVector_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_DoubleVector_retrieve" "', argument " "1"" of type '" "gs::Reference< std::vector< double > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< double > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_DoubleVector_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::vector< double,std::allocator< double > > )gs_Reference_Sl_std_vector_Sl_double_Sg__Sg__retrieve((gs::Reference< std::vector< double > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_DoubleVector_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< double > > arg1 = (gs::Reference< std::vector< double > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< double,std::allocator< double > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_DoubleVector_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_double_std__allocatorT_double_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_DoubleVector_getValue" "', argument " "1"" of type '" "gs::Reference< std::vector< double > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< double > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_DoubleVector_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_vector_Sl_double_Sg__Sg__getValue((gs::Reference< std::vector< double > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_DoubleVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< double > > arg1 = (gs::Reference< std::vector< double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_DoubleVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_DoubleVector" "', argument " "1"" of type '" "gs::Reference< std::vector< double > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< double > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_DoubleVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_LDoubleVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< long double,std::allocator< long double > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::vector< long double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_LDoubleVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< long double,std::allocator< long double > > ptr = (std::vector< long double,std::allocator< long double > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_LDoubleVector" "', argument " "1"" of type '" "std::vector< long double,std::allocator< long double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_LDoubleVector" "', argument " "1"" of type '" "std::vector< long double,std::allocator< long double > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_LDoubleVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_LDoubleVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::vector< long double > > )new gs::ArchiveValueRecord< std::vector< long double > >((std::vector< long double,std::allocator< long double > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_long_double_std__allocatorT_long_double_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_LDoubleVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::vector< long double > > arg1 = (gs::ArchiveValueRecord< std::vector< long double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_LDoubleVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_long_double_std__allocatorT_long_double_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_LDoubleVector" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::vector< long double > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::vector< long double > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_LDoubleVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_long_double_std__allocatorT_long_double_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_LDoubleVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< long double,std::allocator< long double > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::vector< long double,std::allocator< long double > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_LDoubleVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< long double,std::allocator< long double > > ptr = (std::vector< long double,std::allocator< long double > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_LDoubleVector" "', argument " "1"" of type '" "std::vector< long double,std::allocator< long double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_LDoubleVector" "', argument " "1"" of type '" "std::vector< long double,std::allocator< long double > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_LDoubleVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_LDoubleVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::vector< long double > >((std::vector< long double,std::allocator< long double > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::vector< long double,std::allocator< long double > > >(static_cast< const gs::ArchiveValueRecord< std::vector< long double,std::allocator< long double > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_long_double_std__allocatorT_long_double_t_t_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LDoubleVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::vector< long double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_LDoubleVector",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_LDoubleVector" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::vector< long double > > )new gs::Reference< std::vector< long double > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_double_std__allocatorT_long_double_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LDoubleVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< long double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_LDoubleVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_LDoubleVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_LDoubleVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::vector< long double > > )new gs::Reference< std::vector< long double > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_double_std__allocatorT_long_double_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LDoubleVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< long double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_LDoubleVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_LDoubleVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LDoubleVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_LDoubleVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LDoubleVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::vector< long double > > )new gs::Reference< std::vector< long double > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_double_std__allocatorT_long_double_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LDoubleVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_LDoubleVector__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_LDoubleVector__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_LDoubleVector__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_LDoubleVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::vector< long double > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::vector< long double > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::vector< long double > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_LDoubleVector_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< long double > > arg1 = (gs::Reference< std::vector< long double > > ) 0 ;
	unsigned long arg2 ;
	std::vector< long double,std::allocator< long double > > arg3 = (std::vector< long double,std::allocator< long double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_LDoubleVector_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_double_std__allocatorT_long_double_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LDoubleVector_restore" "', argument " "1"" of type '" "gs::Reference< std::vector< long double > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< long double > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LDoubleVector_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__vectorT_long_double_std__allocatorT_long_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_LDoubleVector_restore" "', argument " "3"" of type '" "std::vector< long double,std::allocator< long double > > *""'");
	}
	arg3 = reinterpret_cast< std::vector< long double,std::allocator< long double > > * >(argp3);
	{
	try {
	((gs::Reference< std::vector< long double > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_LDoubleVector_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< long double > > arg1 = (gs::Reference< std::vector< long double > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< long double,std::allocator< long double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_LDoubleVector_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_double_std__allocatorT_long_double_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LDoubleVector_retrieve" "', argument " "1"" of type '" "gs::Reference< std::vector< long double > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< long double > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LDoubleVector_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::vector< long double,std::allocator< long double > > )gs_Reference_Sl_std_vector_Sl_long_SS_double_Sg__Sg__retrieve((gs::Reference< std::vector< long double > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_double_std__allocatorT_long_double_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_LDoubleVector_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< long double > > arg1 = (gs::Reference< std::vector< long double > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< long double,std::allocator< long double > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_LDoubleVector_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_double_std__allocatorT_long_double_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LDoubleVector_getValue" "', argument " "1"" of type '" "gs::Reference< std::vector< long double > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< long double > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LDoubleVector_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_vector_Sl_long_SS_double_Sg__Sg__getValue((gs::Reference< std::vector< long double > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< long double,std::allocator< long double > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_LDoubleVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< long double > > arg1 = (gs::Reference< std::vector< long double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_LDoubleVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_double_std__allocatorT_long_double_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_LDoubleVector" "', argument " "1"" of type '" "gs::Reference< std::vector< long double > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< long double > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_LDoubleVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__vectorT_long_double_std__allocatorT_long_double_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_CFloatVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< std::complex< float >,std::allocator< std::complex< float > > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::vector< std::complex< float > > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_CFloatVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< std::complex< float >,std::allocator< std::complex< float > > > ptr = (std::vector< std::complex< float >,std::allocator< std::complex< float > > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_CFloatVector" "', argument " "1"" of type '" "std::vector< std::complex< float >,std::allocator< std::complex< float > > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_CFloatVector" "', argument " "1"" of type '" "std::vector< std::complex< float >,std::allocator< std::complex< float > > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_CFloatVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_CFloatVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::vector< std::complex< float > > > )new gs::ArchiveValueRecord< std::vector< std::complex< float > > >((std::vector< std::complex< float >,std::allocator< std::complex< float > > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_std__complexT_float_t_std__allocatorT_std__complexT_float_t_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_CFloatVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::vector< std::complex< float > > > arg1 = (gs::ArchiveValueRecord< std::vector< std::complex< float > > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_CFloatVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_std__complexT_float_t_std__allocatorT_std__complexT_float_t_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_CFloatVector" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::vector< std::complex< float > > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::vector< std::complex< float > > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_CFloatVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_std__complexT_float_t_std__allocatorT_std__complexT_float_t_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_CFloatVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< std::complex< float >,std::allocator< std::complex< float > > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::vector< std::complex< float >,std::allocator< std::complex< float > > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_CFloatVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< std::complex< float >,std::allocator< std::complex< float > > > ptr = (std::vector< std::complex< float >,std::allocator< std::complex< float > > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_CFloatVector" "', argument " "1"" of type '" "std::vector< std::complex< float >,std::allocator< std::complex< float > > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_CFloatVector" "', argument " "1"" of type '" "std::vector< std::complex< float >,std::allocator< std::complex< float > > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_CFloatVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_CFloatVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::vector< std::complex< float > > >((std::vector< std::complex< float >,std::allocator< std::complex< float > > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::vector< std::complex< float >,std::allocator< std::complex< float > > > >(static_cast< const gs::ArchiveValueRecord< std::vector< std::complex< float >,std::allocator< std::complex< float > > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_std__complexT_float_t_std__allocatorT_std__complexT_float_t_t_t_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CFloatVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::vector< std::complex< float > > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_CFloatVector",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CFloatVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CFloatVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_CFloatVector" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::vector< std::complex< float > > > )new gs::Reference< std::vector< std::complex< float > > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_float_t_std__allocatorT_std__complexT_float_t_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CFloatVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< std::complex< float > > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_CFloatVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CFloatVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CFloatVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_CFloatVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_CFloatVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::vector< std::complex< float > > > )new gs::Reference< std::vector< std::complex< float > > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_float_t_std__allocatorT_std__complexT_float_t_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CFloatVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< std::complex< float > > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_CFloatVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CFloatVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CFloatVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_CFloatVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CFloatVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_CFloatVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CFloatVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::vector< std::complex< float > > > )new gs::Reference< std::vector< std::complex< float > > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_float_t_std__allocatorT_std__complexT_float_t_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CFloatVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_CFloatVector__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_CFloatVector__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_CFloatVector__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_CFloatVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::vector< std::complex< float > > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::vector< std::complex< float > > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::vector< std::complex< float > > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_CFloatVector_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< std::complex< float > > > arg1 = (gs::Reference< std::vector< std::complex< float > > > ) 0 ;
	unsigned long arg2 ;
	std::vector< std::complex< float >,std::allocator< std::complex< float > > > arg3 = (std::vector< std::complex< float >,std::allocator< std::complex< float > > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_CFloatVector_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_float_t_std__allocatorT_std__complexT_float_t_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CFloatVector_restore" "', argument " "1"" of type '" "gs::Reference< std::vector< std::complex< float > > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< std::complex< float > > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CFloatVector_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__vectorT_std__complexT_float_t_std__allocatorT_std__complexT_float_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_CFloatVector_restore" "', argument " "3"" of type '" "std::vector< std::complex< float >,std::allocator< std::complex< float > > > *""'");
	}
	arg3 = reinterpret_cast< std::vector< std::complex< float >,std::allocator< std::complex< float > > > * >(argp3);
	{
	try {
	((gs::Reference< std::vector< std::complex< float > > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_CFloatVector_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< std::complex< float > > > arg1 = (gs::Reference< std::vector< std::complex< float > > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< std::complex< float >,std::allocator< std::complex< float > > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_CFloatVector_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_float_t_std__allocatorT_std__complexT_float_t_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CFloatVector_retrieve" "', argument " "1"" of type '" "gs::Reference< std::vector< std::complex< float > > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< std::complex< float > > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CFloatVector_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::vector< std::complex< float >,std::allocator< std::complex< float > > > )gs_Reference_Sl_std_vector_Sl_std_complex_Sl_float_Sg__Sg__Sg__retrieve((gs::Reference< std::vector< std::complex< float > > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__complexT_float_t_std__allocatorT_std__complexT_float_t_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_CFloatVector_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< std::complex< float > > > arg1 = (gs::Reference< std::vector< std::complex< float > > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< std::complex< float >,std::allocator< std::complex< float > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_CFloatVector_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_float_t_std__allocatorT_std__complexT_float_t_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CFloatVector_getValue" "', argument " "1"" of type '" "gs::Reference< std::vector< std::complex< float > > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< std::complex< float > > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CFloatVector_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_vector_Sl_std_complex_Sl_float_Sg__Sg__Sg__getValue((gs::Reference< std::vector< std::complex< float > > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< std::complex< float >,std::allocator< std::complex< float > > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_CFloatVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< std::complex< float > > > arg1 = (gs::Reference< std::vector< std::complex< float > > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_CFloatVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_float_t_std__allocatorT_std__complexT_float_t_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_CFloatVector" "', argument " "1"" of type '" "gs::Reference< std::vector< std::complex< float > > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< std::complex< float > > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_CFloatVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_float_t_std__allocatorT_std__complexT_float_t_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_CDoubleVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< std::complex< double >,std::allocator< std::complex< double > > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::vector< std::complex< double > > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_CDoubleVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< std::complex< double >,std::allocator< std::complex< double > > > ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_CDoubleVector" "', argument " "1"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_CDoubleVector" "', argument " "1"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_CDoubleVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_CDoubleVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::vector< std::complex< double > > > )new gs::ArchiveValueRecord< std::vector< std::complex< double > > >((std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_CDoubleVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::vector< std::complex< double > > > arg1 = (gs::ArchiveValueRecord< std::vector< std::complex< double > > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_CDoubleVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_CDoubleVector" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::vector< std::complex< double > > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::vector< std::complex< double > > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_CDoubleVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_CDoubleVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< std::complex< double >,std::allocator< std::complex< double > > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::vector< std::complex< double >,std::allocator< std::complex< double > > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_CDoubleVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< std::complex< double >,std::allocator< std::complex< double > > > ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_CDoubleVector" "', argument " "1"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_CDoubleVector" "', argument " "1"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_CDoubleVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_CDoubleVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::vector< std::complex< double > > >((std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::vector< std::complex< double >,std::allocator< std::complex< double > > > >(static_cast< const gs::ArchiveValueRecord< std::vector< std::complex< double >,std::allocator< std::complex< double > > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CDoubleVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::vector< std::complex< double > > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_CDoubleVector",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_CDoubleVector" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::vector< std::complex< double > > > )new gs::Reference< std::vector< std::complex< double > > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CDoubleVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< std::complex< double > > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_CDoubleVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_CDoubleVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_CDoubleVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::vector< std::complex< double > > > )new gs::Reference< std::vector< std::complex< double > > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CDoubleVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< std::complex< double > > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_CDoubleVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_CDoubleVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CDoubleVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_CDoubleVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CDoubleVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::vector< std::complex< double > > > )new gs::Reference< std::vector< std::complex< double > > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CDoubleVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_CDoubleVector__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_CDoubleVector__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_CDoubleVector__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_CDoubleVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::vector< std::complex< double > > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::vector< std::complex< double > > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::vector< std::complex< double > > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_CDoubleVector_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< std::complex< double > > > arg1 = (gs::Reference< std::vector< std::complex< double > > > ) 0 ;
	unsigned long arg2 ;
	std::vector< std::complex< double >,std::allocator< std::complex< double > > > arg3 = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_CDoubleVector_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CDoubleVector_restore" "', argument " "1"" of type '" "gs::Reference< std::vector< std::complex< double > > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< std::complex< double > > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CDoubleVector_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_CDoubleVector_restore" "', argument " "3"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > *""'");
	}
	arg3 = reinterpret_cast< std::vector< std::complex< double >,std::allocator< std::complex< double > > > * >(argp3);
	{
	try {
	((gs::Reference< std::vector< std::complex< double > > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_CDoubleVector_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< std::complex< double > > > arg1 = (gs::Reference< std::vector< std::complex< double > > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< std::complex< double >,std::allocator< std::complex< double > > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_CDoubleVector_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CDoubleVector_retrieve" "', argument " "1"" of type '" "gs::Reference< std::vector< std::complex< double > > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< std::complex< double > > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CDoubleVector_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > )gs_Reference_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__retrieve((gs::Reference< std::vector< std::complex< double > > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_CDoubleVector_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< std::complex< double > > > arg1 = (gs::Reference< std::vector< std::complex< double > > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< std::complex< double >,std::allocator< std::complex< double > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_CDoubleVector_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CDoubleVector_getValue" "', argument " "1"" of type '" "gs::Reference< std::vector< std::complex< double > > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< std::complex< double > > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CDoubleVector_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_vector_Sl_std_complex_Sl_double_Sg__Sg__Sg__getValue((gs::Reference< std::vector< std::complex< double > > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< std::complex< double >,std::allocator< std::complex< double > > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_CDoubleVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< std::complex< double > > > arg1 = (gs::Reference< std::vector< std::complex< double > > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_CDoubleVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_CDoubleVector" "', argument " "1"" of type '" "gs::Reference< std::vector< std::complex< double > > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< std::complex< double > > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_CDoubleVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_CLDoubleVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::vector< std::complex< long double > > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_CLDoubleVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > ptr = (std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_CLDoubleVector" "', argument " "1"" of type '" "std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_CLDoubleVector" "', argument " "1"" of type '" "std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_CLDoubleVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_CLDoubleVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::vector< std::complex< long double > > > )new gs::ArchiveValueRecord< std::vector< std::complex< long double > > >((std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_std__complexT_long_double_t_std__allocatorT_std__complexT_long_double_t_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_CLDoubleVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::vector< std::complex< long double > > > arg1 = (gs::ArchiveValueRecord< std::vector< std::complex< long double > > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_CLDoubleVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_std__complexT_long_double_t_std__allocatorT_std__complexT_long_double_t_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_CLDoubleVector" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::vector< std::complex< long double > > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::vector< std::complex< long double > > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_CLDoubleVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_std__complexT_long_double_t_std__allocatorT_std__complexT_long_double_t_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_CLDoubleVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_CLDoubleVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > ptr = (std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > )0;
	res1 = swig::asptr(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_CLDoubleVector" "', argument " "1"" of type '" "std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_CLDoubleVector" "', argument " "1"" of type '" "std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_CLDoubleVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_CLDoubleVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::vector< std::complex< long double > > >((std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > >(static_cast< const gs::ArchiveValueRecord< std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_std__complexT_long_double_t_std__allocatorT_std__complexT_long_double_t_t_t_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CLDoubleVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::vector< std::complex< long double > > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_CLDoubleVector",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CLDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CLDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_CLDoubleVector" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::vector< std::complex< long double > > > )new gs::Reference< std::vector< std::complex< long double > > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_long_double_t_std__allocatorT_std__complexT_long_double_t_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CLDoubleVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< std::complex< long double > > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_CLDoubleVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CLDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CLDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_CLDoubleVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_CLDoubleVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::vector< std::complex< long double > > > )new gs::Reference< std::vector< std::complex< long double > > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_long_double_t_std__allocatorT_std__complexT_long_double_t_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CLDoubleVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< std::complex< long double > > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_CLDoubleVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CLDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CLDoubleVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_CLDoubleVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CLDoubleVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_CLDoubleVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CLDoubleVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::vector< std::complex< long double > > > )new gs::Reference< std::vector< std::complex< long double > > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_long_double_t_std__allocatorT_std__complexT_long_double_t_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CLDoubleVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_CLDoubleVector__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_CLDoubleVector__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_CLDoubleVector__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_CLDoubleVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::vector< std::complex< long double > > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::vector< std::complex< long double > > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::vector< std::complex< long double > > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_CLDoubleVector_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< std::complex< long double > > > arg1 = (gs::Reference< std::vector< std::complex< long double > > > ) 0 ;
	unsigned long arg2 ;
	std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > arg3 = (std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_CLDoubleVector_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_long_double_t_std__allocatorT_std__complexT_long_double_t_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CLDoubleVector_restore" "', argument " "1"" of type '" "gs::Reference< std::vector< std::complex< long double > > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< std::complex< long double > > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CLDoubleVector_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__vectorT_std__complexT_long_double_t_std__allocatorT_std__complexT_long_double_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_CLDoubleVector_restore" "', argument " "3"" of type '" "std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > *""'");
	}
	arg3 = reinterpret_cast< std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > * >(argp3);
	{
	try {
	((gs::Reference< std::vector< std::complex< long double > > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_CLDoubleVector_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< std::complex< long double > > > arg1 = (gs::Reference< std::vector< std::complex< long double > > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_CLDoubleVector_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_long_double_t_std__allocatorT_std__complexT_long_double_t_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CLDoubleVector_retrieve" "', argument " "1"" of type '" "gs::Reference< std::vector< std::complex< long double > > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< std::complex< long double > > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CLDoubleVector_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > )gs_Reference_Sl_std_vector_Sl_std_complex_Sl_long_SS_double_Sg__Sg__Sg__retrieve((gs::Reference< std::vector< std::complex< long double > > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__complexT_long_double_t_std__allocatorT_std__complexT_long_double_t_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_CLDoubleVector_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< std::complex< long double > > > arg1 = (gs::Reference< std::vector< std::complex< long double > > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_CLDoubleVector_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_long_double_t_std__allocatorT_std__complexT_long_double_t_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CLDoubleVector_getValue" "', argument " "1"" of type '" "gs::Reference< std::vector< std::complex< long double > > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< std::complex< long double > > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CLDoubleVector_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_vector_Sl_std_complex_Sl_long_SS_double_Sg__Sg__Sg__getValue((gs::Reference< std::vector< std::complex< long double > > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = swig::from(static_cast< std::vector< std::complex< long double >,std::allocator< std::complex< long double > > > >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_CLDoubleVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< std::complex< long double > > > arg1 = (gs::Reference< std::vector< std::complex< long double > > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_CLDoubleVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_long_double_t_std__allocatorT_std__complexT_long_double_t_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_CLDoubleVector" "', argument " "1"" of type '" "gs::Reference< std::vector< std::complex< long double > > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< std::complex< long double > > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_CLDoubleVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__complexT_long_double_t_std__allocatorT_std__complexT_long_double_t_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_StringVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< std::string,std::allocator< std::string > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::vector< std::string > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_StringVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	if (PySequence_Check(obj0))
	{
	arg1 = new std::vector<std::string>();
	const Py_ssize_t size = PySequence_Size(obj0);
	arg1->reserve(size);
	for (Py_ssize_t i=0; i<size; ++i)
	{
	PyObject *o = PySequence_GetItem(obj0, i);
	assert(o);
	if (PyUnicode_Check(o))
	{
	PyObject* pyStr = PyUnicode_AsEncodedString(o, "utf-8", "Error -");
	assert(pyStr);
	const char* contents = PyBytes_AsString(pyStr);
	assert(contents);
	arg1->push_back(std::string(contents));
	Py_DECREF(pyStr);
	Py_DECREF(o);
	}
	else
	{
	Py_DECREF(o);
	delete arg1;
	SWIG_exception(SWIG_TypeError, "sequence must contain only strings");
	return NULL;
	}
	}
	}
	else
	{
	SWIG_exception(SWIG_TypeError, "expected a sequence of strings");
	return NULL;
	}
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_StringVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_StringVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::vector< std::string > > )new gs::ArchiveValueRecord< std::vector< std::string > >((std::vector< std::string,std::allocator< std::string > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, SWIG_POINTER_NEW \| 0 );
	{
	delete arg1;
	}
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	{
	delete arg1;
	}
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_StringVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::vector< std::string > > arg1 = (gs::ArchiveValueRecord< std::vector< std::string > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_StringVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_StringVector" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::vector< std::string > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::vector< std::string > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_StringVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_StringVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::vector< std::string,std::allocator< std::string > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,std::allocator< std::basic_string< char,std::char_traits< char >,std::allocator< char > > > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_StringVector",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	if (PySequence_Check(obj0))
	{
	arg1 = new std::vector<std::string>();
	const Py_ssize_t size = PySequence_Size(obj0);
	arg1->reserve(size);
	for (Py_ssize_t i=0; i<size; ++i)
	{
	PyObject *o = PySequence_GetItem(obj0, i);
	assert(o);
	if (PyUnicode_Check(o))
	{
	PyObject* pyStr = PyUnicode_AsEncodedString(o, "utf-8", "Error -");
	assert(pyStr);
	const char* contents = PyBytes_AsString(pyStr);
	assert(contents);
	arg1->push_back(std::string(contents));
	Py_DECREF(pyStr);
	Py_DECREF(o);
	}
	else
	{
	Py_DECREF(o);
	delete arg1;
	SWIG_exception(SWIG_TypeError, "sequence must contain only strings");
	return NULL;
	}
	}
	}
	else
	{
	SWIG_exception(SWIG_TypeError, "expected a sequence of strings");
	return NULL;
	}
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_StringVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_StringVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::vector< std::string > >((std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > >,std::allocator< std::basic_string< char,std::char_traits< char >,std::allocator< char > > > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::vector< std::string,std::allocator< std::string > > >(static_cast< const gs::ArchiveValueRecord< std::vector< std::string,std::allocator< std::string > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, SWIG_POINTER_OWN \| 0 );
	{
	delete arg1;
	}
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	{
	delete arg1;
	}
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_StringVector__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::vector< std::string > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_StringVector",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_StringVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_StringVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_StringVector" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::vector< std::string > > )new gs::Reference< std::vector< std::string > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_StringVector__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< std::string > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_StringVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_StringVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_StringVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_StringVector" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_StringVector" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::vector< std::string > > )new gs::Reference< std::vector< std::string > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_StringVector__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::vector< std::string > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_StringVector",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_StringVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_StringVector" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_StringVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_StringVector" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_StringVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_StringVector" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::vector< std::string > > )new gs::Reference< std::vector< std::string > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_StringVector(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_StringVector__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_StringVector__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_StringVector__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_StringVector'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::vector< std::string > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::vector< std::string > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::vector< std::string > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_StringVector_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< std::string > > arg1 = (gs::Reference< std::vector< std::string > > ) 0 ;
	unsigned long arg2 ;
	std::vector< std::string,std::allocator< std::string > > arg3 = (std::vector< std::string,std::allocator< std::string > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_StringVector_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_StringVector_restore" "', argument " "1"" of type '" "gs::Reference< std::vector< std::string > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< std::string > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_StringVector_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__vectorT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_std__allocatorT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_StringVector_restore" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > *""'");
	}
	arg3 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp3);
	{
	try {
	((gs::Reference< std::vector< std::string > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_StringVector_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< std::string > > arg1 = (gs::Reference< std::vector< std::string > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< std::string,std::allocator< std::string > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_StringVector_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_StringVector_retrieve" "', argument " "1"" of type '" "gs::Reference< std::vector< std::string > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< std::string > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_StringVector_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::vector< std::string,std::allocator< std::string > > )gs_Reference_Sl_std_vector_Sl_std_string_Sg__Sg__retrieve((gs::Reference< std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_std__allocatorT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_StringVector_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< std::string > > arg1 = (gs::Reference< std::vector< std::string > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::vector< std::string,std::allocator< std::string > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_StringVector_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_StringVector_getValue" "', argument " "1"" of type '" "gs::Reference< std::vector< std::string > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< std::string > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_StringVector_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_vector_Sl_std_string_Sg__Sg__getValue((gs::Reference< std::vector< std::basic_string< char,std::char_traits< char >,std::allocator< char > > > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	{
	const unsigned long vsize = (&result)->size();
	resultobj = PyList_New(vsize);
	if (resultobj)
	{
	bool ok = true;
	for (unsigned long i=0; i<vsize && ok; ++i)
	{
	PyObject* copy = PyUnicode_FromString((result[i]).c_str());
	if (copy == NULL)
	ok = false;
	else
	PyList_SET_ITEM(resultobj, i, copy);
	}
	if (!ok)
	{
	Py_DECREF(resultobj);
	resultobj = NULL;
	}
	}
	}
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_StringVector(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::vector< std::string > > arg1 = (gs::Reference< std::vector< std::string > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_StringVector",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_StringVector" "', argument " "1"" of type '" "gs::Reference< std::vector< std::string > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::vector< std::string > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_StringVector_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_histoBars__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	std::vector< double,std::allocator< double > > *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	int res5 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:histoBars",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res5 = swig::asptr(obj4, &ptr);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg5 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars< npstat::HistoND< int,npstat::HistoAxis > >((npstat::HistoND< int,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res5)) delete arg5;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res5)) delete arg5;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	std::vector< double,std::allocator< double > > *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	int res5 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:histoBars",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res5 = swig::asptr(obj4, &ptr);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg5 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars< npstat::HistoND< long long,npstat::HistoAxis > >((npstat::HistoND< long long,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res5)) delete arg5;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res5)) delete arg5;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	std::vector< double,std::allocator< double > > *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	int res5 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:histoBars",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res5 = swig::asptr(obj4, &ptr);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg5 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars< npstat::HistoND< float,npstat::HistoAxis > >((npstat::HistoND< float,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res5)) delete arg5;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res5)) delete arg5;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	std::vector< double,std::allocator< double > > *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	int res5 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:histoBars",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res5 = swig::asptr(obj4, &ptr);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg5 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars< npstat::HistoND< double,npstat::HistoAxis > >((npstat::HistoND< double,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res5)) delete arg5;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res5)) delete arg5;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	std::vector< double,std::allocator< double > > *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	int res5 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:histoBars",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res5 = swig::asptr(obj4, &ptr);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg5 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars< npstat::HistoND< unsigned char,npstat::HistoAxis > >((npstat::HistoND< unsigned char,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res5)) delete arg5;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res5)) delete arg5;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	std::vector< double,std::allocator< double > > *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	int res5 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:histoBars",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res5 = swig::asptr(obj4, &ptr);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg5 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars< npstat::HistoND< int,npstat::NUHistoAxis > >((npstat::HistoND< int,npstat::NUHistoAxis > const &)arg1,arg2,arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res5)) delete arg5;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res5)) delete arg5;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	std::vector< double,std::allocator< double > > *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	int res5 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:histoBars",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res5 = swig::asptr(obj4, &ptr);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg5 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars< npstat::HistoND< long long,npstat::NUHistoAxis > >((npstat::HistoND< long long,npstat::NUHistoAxis > const &)arg1,arg2,arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res5)) delete arg5;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res5)) delete arg5;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	std::vector< double,std::allocator< double > > *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	int res5 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:histoBars",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res5 = swig::asptr(obj4, &ptr);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg5 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars< npstat::HistoND< float,npstat::NUHistoAxis > >((npstat::HistoND< float,npstat::NUHistoAxis > const &)arg1,arg2,arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res5)) delete arg5;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res5)) delete arg5;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	std::vector< double,std::allocator< double > > *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	int res5 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:histoBars",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res5 = swig::asptr(obj4, &ptr);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg5 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars< npstat::HistoND< double,npstat::NUHistoAxis > >((npstat::HistoND< double,npstat::NUHistoAxis > const &)arg1,arg2,arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res5)) delete arg5;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res5)) delete arg5;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	std::vector< double,std::allocator< double > > *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	int res5 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:histoBars",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res5 = swig::asptr(obj4, &ptr);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg5 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars< npstat::HistoND< unsigned char,npstat::NUHistoAxis > >((npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &)arg1,arg2,arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res5)) delete arg5;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res5)) delete arg5;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	std::vector< double,std::allocator< double > > *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	int res5 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:histoBars",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res5 = swig::asptr(obj4, &ptr);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg5 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars< npstat::HistoND< int,npstat::DualHistoAxis > >((npstat::HistoND< int,npstat::DualHistoAxis > const &)arg1,arg2,arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res5)) delete arg5;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res5)) delete arg5;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars__SWIG_12(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	std::vector< double,std::allocator< double > > *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	int res5 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:histoBars",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res5 = swig::asptr(obj4, &ptr);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg5 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars< npstat::HistoND< long long,npstat::DualHistoAxis > >((npstat::HistoND< long long,npstat::DualHistoAxis > const &)arg1,arg2,arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res5)) delete arg5;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res5)) delete arg5;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars__SWIG_13(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	std::vector< double,std::allocator< double > > *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	int res5 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:histoBars",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res5 = swig::asptr(obj4, &ptr);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg5 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars< npstat::HistoND< float,npstat::DualHistoAxis > >((npstat::HistoND< float,npstat::DualHistoAxis > const &)arg1,arg2,arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res5)) delete arg5;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res5)) delete arg5;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars__SWIG_14(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	std::vector< double,std::allocator< double > > *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	int res5 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:histoBars",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res5 = swig::asptr(obj4, &ptr);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg5 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars< npstat::HistoND< double,npstat::DualHistoAxis > >((npstat::HistoND< double,npstat::DualHistoAxis > const &)arg1,arg2,arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res5)) delete arg5;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res5)) delete arg5;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars__SWIG_15(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	std::vector< double,std::allocator< double > > *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	int res5 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:histoBars",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res5 = swig::asptr(obj4, &ptr);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg5 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars< npstat::HistoND< unsigned char,npstat::DualHistoAxis > >((npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &)arg1,arg2,arg3,arg4,(std::vector< double,std::allocator< double > > const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res5)) delete arg5;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res5)) delete arg5;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars__SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars__SWIG_2(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars__SWIG_3(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars__SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars__SWIG_7(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars__SWIG_8(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars__SWIG_9(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars__SWIG_10(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars__SWIG_11(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars__SWIG_12(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars__SWIG_13(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars__SWIG_14(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars__SWIG_15(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'histoBars'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::histoBars< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars< npstat::HistoND< int,npstat::NUHistoAxis > >(npstat::HistoND< int,npstat::NUHistoAxis > const &,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars< npstat::HistoND< long long,npstat::NUHistoAxis > >(npstat::HistoND< long long,npstat::NUHistoAxis > const &,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars< npstat::HistoND< float,npstat::NUHistoAxis > >(npstat::HistoND< float,npstat::NUHistoAxis > const &,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars< npstat::HistoND< double,npstat::NUHistoAxis > >(npstat::HistoND< double,npstat::NUHistoAxis > const &,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars< npstat::HistoND< unsigned char,npstat::NUHistoAxis > >(npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars< npstat::HistoND< int,npstat::DualHistoAxis > >(npstat::HistoND< int,npstat::DualHistoAxis > const &,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars< npstat::HistoND< long long,npstat::DualHistoAxis > >(npstat::HistoND< long long,npstat::DualHistoAxis > const &,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars< npstat::HistoND< float,npstat::DualHistoAxis > >(npstat::HistoND< float,npstat::DualHistoAxis > const &,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars< npstat::HistoND< double,npstat::DualHistoAxis > >(npstat::HistoND< double,npstat::DualHistoAxis > const &,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars< npstat::HistoND< unsigned char,npstat::DualHistoAxis > >(npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_histoBars3d__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 ;
	double arg6 ;
	std::vector< double,std::allocator< double > > *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	int res7 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:histoBars3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars3d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars3d" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars3d" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "histoBars3d" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "histoBars3d" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res7 = swig::asptr(obj6, &ptr);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg7 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars3d< npstat::HistoND< int,npstat::HistoAxis > >((npstat::HistoND< int,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,arg5,arg6,(std::vector< double,std::allocator< double > > const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res7)) delete arg7;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res7)) delete arg7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars3d__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 ;
	double arg6 ;
	std::vector< double,std::allocator< double > > *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	int res7 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:histoBars3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars3d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars3d" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars3d" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "histoBars3d" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "histoBars3d" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res7 = swig::asptr(obj6, &ptr);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg7 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars3d< npstat::HistoND< long long,npstat::HistoAxis > >((npstat::HistoND< long long,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,arg5,arg6,(std::vector< double,std::allocator< double > > const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res7)) delete arg7;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res7)) delete arg7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars3d__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 ;
	double arg6 ;
	std::vector< double,std::allocator< double > > *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	int res7 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:histoBars3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars3d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars3d" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars3d" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "histoBars3d" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "histoBars3d" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res7 = swig::asptr(obj6, &ptr);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg7 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars3d< npstat::HistoND< float,npstat::HistoAxis > >((npstat::HistoND< float,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,arg5,arg6,(std::vector< double,std::allocator< double > > const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res7)) delete arg7;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res7)) delete arg7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars3d__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 ;
	double arg6 ;
	std::vector< double,std::allocator< double > > *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	int res7 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:histoBars3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars3d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars3d" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars3d" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "histoBars3d" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "histoBars3d" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res7 = swig::asptr(obj6, &ptr);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg7 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars3d< npstat::HistoND< double,npstat::HistoAxis > >((npstat::HistoND< double,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,arg5,arg6,(std::vector< double,std::allocator< double > > const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res7)) delete arg7;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res7)) delete arg7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars3d__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 ;
	double arg6 ;
	std::vector< double,std::allocator< double > > *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	int res7 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:histoBars3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars3d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars3d" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars3d" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "histoBars3d" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "histoBars3d" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res7 = swig::asptr(obj6, &ptr);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg7 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars3d< npstat::HistoND< unsigned char,npstat::HistoAxis > >((npstat::HistoND< unsigned char,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,arg5,arg6,(std::vector< double,std::allocator< double > > const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res7)) delete arg7;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res7)) delete arg7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars3d__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 ;
	double arg6 ;
	std::vector< double,std::allocator< double > > *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	int res7 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:histoBars3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars3d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars3d" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars3d" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "histoBars3d" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "histoBars3d" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res7 = swig::asptr(obj6, &ptr);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg7 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars3d< npstat::HistoND< int,npstat::NUHistoAxis > >((npstat::HistoND< int,npstat::NUHistoAxis > const &)arg1,arg2,arg3,arg4,arg5,arg6,(std::vector< double,std::allocator< double > > const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res7)) delete arg7;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res7)) delete arg7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars3d__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 ;
	double arg6 ;
	std::vector< double,std::allocator< double > > *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	int res7 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:histoBars3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars3d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars3d" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars3d" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "histoBars3d" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "histoBars3d" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res7 = swig::asptr(obj6, &ptr);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg7 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars3d< npstat::HistoND< long long,npstat::NUHistoAxis > >((npstat::HistoND< long long,npstat::NUHistoAxis > const &)arg1,arg2,arg3,arg4,arg5,arg6,(std::vector< double,std::allocator< double > > const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res7)) delete arg7;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res7)) delete arg7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars3d__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 ;
	double arg6 ;
	std::vector< double,std::allocator< double > > *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	int res7 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:histoBars3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars3d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars3d" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars3d" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "histoBars3d" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "histoBars3d" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res7 = swig::asptr(obj6, &ptr);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg7 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars3d< npstat::HistoND< float,npstat::NUHistoAxis > >((npstat::HistoND< float,npstat::NUHistoAxis > const &)arg1,arg2,arg3,arg4,arg5,arg6,(std::vector< double,std::allocator< double > > const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res7)) delete arg7;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res7)) delete arg7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars3d__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 ;
	double arg6 ;
	std::vector< double,std::allocator< double > > *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	int res7 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:histoBars3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars3d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars3d" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars3d" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "histoBars3d" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "histoBars3d" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res7 = swig::asptr(obj6, &ptr);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg7 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars3d< npstat::HistoND< double,npstat::NUHistoAxis > >((npstat::HistoND< double,npstat::NUHistoAxis > const &)arg1,arg2,arg3,arg4,arg5,arg6,(std::vector< double,std::allocator< double > > const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res7)) delete arg7;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res7)) delete arg7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars3d__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 ;
	double arg6 ;
	std::vector< double,std::allocator< double > > *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	int res7 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:histoBars3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars3d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars3d" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars3d" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "histoBars3d" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "histoBars3d" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res7 = swig::asptr(obj6, &ptr);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg7 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars3d< npstat::HistoND< unsigned char,npstat::NUHistoAxis > >((npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &)arg1,arg2,arg3,arg4,arg5,arg6,(std::vector< double,std::allocator< double > > const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res7)) delete arg7;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res7)) delete arg7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars3d__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 ;
	double arg6 ;
	std::vector< double,std::allocator< double > > *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	int res7 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:histoBars3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars3d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars3d" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars3d" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "histoBars3d" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "histoBars3d" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res7 = swig::asptr(obj6, &ptr);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg7 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars3d< npstat::HistoND< int,npstat::DualHistoAxis > >((npstat::HistoND< int,npstat::DualHistoAxis > const &)arg1,arg2,arg3,arg4,arg5,arg6,(std::vector< double,std::allocator< double > > const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res7)) delete arg7;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res7)) delete arg7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars3d__SWIG_12(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 ;
	double arg6 ;
	std::vector< double,std::allocator< double > > *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	int res7 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:histoBars3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars3d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars3d" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars3d" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "histoBars3d" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "histoBars3d" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res7 = swig::asptr(obj6, &ptr);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg7 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars3d< npstat::HistoND< long long,npstat::DualHistoAxis > >((npstat::HistoND< long long,npstat::DualHistoAxis > const &)arg1,arg2,arg3,arg4,arg5,arg6,(std::vector< double,std::allocator< double > > const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res7)) delete arg7;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res7)) delete arg7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars3d__SWIG_13(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 ;
	double arg6 ;
	std::vector< double,std::allocator< double > > *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	int res7 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:histoBars3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars3d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars3d" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars3d" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "histoBars3d" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "histoBars3d" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res7 = swig::asptr(obj6, &ptr);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg7 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars3d< npstat::HistoND< float,npstat::DualHistoAxis > >((npstat::HistoND< float,npstat::DualHistoAxis > const &)arg1,arg2,arg3,arg4,arg5,arg6,(std::vector< double,std::allocator< double > > const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res7)) delete arg7;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res7)) delete arg7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars3d__SWIG_14(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 ;
	double arg6 ;
	std::vector< double,std::allocator< double > > *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	int res7 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:histoBars3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars3d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars3d" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars3d" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "histoBars3d" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "histoBars3d" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res7 = swig::asptr(obj6, &ptr);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg7 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars3d< npstat::HistoND< double,npstat::DualHistoAxis > >((npstat::HistoND< double,npstat::DualHistoAxis > const &)arg1,arg2,arg3,arg4,arg5,arg6,(std::vector< double,std::allocator< double > > const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res7)) delete arg7;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res7)) delete arg7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars3d__SWIG_15(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	double arg4 ;
	double arg5 ;
	double arg6 ;
	std::vector< double,std::allocator< double > > *arg7 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	int res7 = SWIG_OLDOBJ ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject * obj6 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:histoBars3d",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBars3d" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "histoBars3d" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "histoBars3d" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "histoBars3d" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "histoBars3d" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	std::vector< double,std::allocator< double > > ptr = (std::vector< double,std::allocator< double > > )0;
	res7 = swig::asptr(obj6, &ptr);
	if (!SWIG_IsOK(res7)) {
	SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBars3d" "', argument " "7"" of type '" "std::vector< double,std::allocator< double > > const &""'");
	}
	arg7 = ptr;
	}
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBars3d< npstat::HistoND< unsigned char,npstat::DualHistoAxis > >((npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &)arg1,arg2,arg3,arg4,arg5,arg6,(std::vector< double,std::allocator< double > > const &)*arg7);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	if (SWIG_IsNewObj(res7)) delete arg7;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res7)) delete arg7;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBars3d(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[8] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 7) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars3d__SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars3d__SWIG_2(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars3d__SWIG_3(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars3d__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars3d__SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars3d__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars3d__SWIG_7(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars3d__SWIG_8(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars3d__SWIG_9(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars3d__SWIG_10(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars3d__SWIG_11(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars3d__SWIG_12(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars3d__SWIG_13(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars3d__SWIG_14(self, args);
	}
	}
	}
	}
	}
	}
	}
	}
	if (argc == 7) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = swig::asptr(argv[6], (std::vector< double,std::allocator< double > >**)(0));
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBars3d__SWIG_15(self, args);
	}
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'histoBars3d'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::histoBars3d< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &,double const,double const,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars3d< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &,double const,double const,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars3d< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &,double const,double const,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars3d< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &,double const,double const,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars3d< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &,double const,double const,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars3d< npstat::HistoND< int,npstat::NUHistoAxis > >(npstat::HistoND< int,npstat::NUHistoAxis > const &,double const,double const,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars3d< npstat::HistoND< long long,npstat::NUHistoAxis > >(npstat::HistoND< long long,npstat::NUHistoAxis > const &,double const,double const,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars3d< npstat::HistoND< float,npstat::NUHistoAxis > >(npstat::HistoND< float,npstat::NUHistoAxis > const &,double const,double const,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars3d< npstat::HistoND< double,npstat::NUHistoAxis > >(npstat::HistoND< double,npstat::NUHistoAxis > const &,double const,double const,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars3d< npstat::HistoND< unsigned char,npstat::NUHistoAxis > >(npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &,double const,double const,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars3d< npstat::HistoND< int,npstat::DualHistoAxis > >(npstat::HistoND< int,npstat::DualHistoAxis > const &,double const,double const,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars3d< npstat::HistoND< long long,npstat::DualHistoAxis > >(npstat::HistoND< long long,npstat::DualHistoAxis > const &,double const,double const,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars3d< npstat::HistoND< float,npstat::DualHistoAxis > >(npstat::HistoND< float,npstat::DualHistoAxis > const &,double const,double const,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars3d< npstat::HistoND< double,npstat::DualHistoAxis > >(npstat::HistoND< double,npstat::DualHistoAxis > const &,double const,double const,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n"
	" npstat::histoBars3d< npstat::HistoND< unsigned char,npstat::DualHistoAxis > >(npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &,double const,double const,double const,double const,double const,std::vector< double,std::allocator< double > > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_templateParameters(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:templateParameters",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "templateParameters" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "templateParameters" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	{
	try {
	result = (PyObject )npstat::templateParameters((gs::ClassId const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDFromNumpyBool(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	bool arg1 = (bool ) 0 ;
	long arg2 = (long ) 0 ;
	int arg3 ;
	PyArrayObject *array1 = NULL ;
	int is_new_object1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< unsigned char,1U,10U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:arrayNDFromNumpyBool",&obj0)) SWIG_fail;
	{
	array1 = obj_to_array_contiguous_allow_conversion(obj0,
	npstat::NumpyTypecode<bool >::code, &is_new_object1);
	if (!array1) SWIG_fail;
	arg1 = (bool*)array_data(array1);
	arg2 = array_dimensions(array1);
	arg3 = array_numdims(array1);
	}
	{
	try {
	result = (npstat::ArrayND< unsigned char,1U,10U > *)npstat::arrayNDFromNumpyBool(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_unsigned_char_1U_10U_t, SWIG_POINTER_OWN \| 0 );
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDFromNumpyUChar(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned char arg1 = (unsigned char ) 0 ;
	long arg2 = (long ) 0 ;
	int arg3 ;
	PyArrayObject *array1 = NULL ;
	int is_new_object1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< unsigned char,1U,10U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:arrayNDFromNumpyUChar",&obj0)) SWIG_fail;
	{
	array1 = obj_to_array_contiguous_allow_conversion(obj0,
	npstat::NumpyTypecode<unsigned char >::code, &is_new_object1);
	if (!array1) SWIG_fail;
	arg1 = (unsigned char*)array_data(array1);
	arg2 = array_dimensions(array1);
	arg3 = array_numdims(array1);
	}
	{
	try {
	result = (npstat::ArrayND< unsigned char,1U,10U > *)npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDFromNumpy< unsigned char >(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_unsigned_char_1U_10U_t, SWIG_POINTER_OWN \| 0 );
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDFromNumpyInt(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int arg1 = (int ) 0 ;
	long arg2 = (long ) 0 ;
	int arg3 ;
	PyArrayObject *array1 = NULL ;
	int is_new_object1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< int,1U,10U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:arrayNDFromNumpyInt",&obj0)) SWIG_fail;
	{
	array1 = obj_to_array_contiguous_allow_conversion(obj0,
	npstat::NumpyTypecode<int >::code, &is_new_object1);
	if (!array1) SWIG_fail;
	arg1 = (int*)array_data(array1);
	arg2 = array_dimensions(array1);
	arg3 = array_numdims(array1);
	}
	{
	try {
	result = (npstat::ArrayND< int,1U,10U > *)npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDFromNumpy< int >(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_int_1U_10U_t, SWIG_POINTER_OWN \| 0 );
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDFromNumpyLLong(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	long long arg1 = (long long ) 0 ;
	long arg2 = (long ) 0 ;
	int arg3 ;
	PyArrayObject *array1 = NULL ;
	int is_new_object1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< long long,1U,10U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:arrayNDFromNumpyLLong",&obj0)) SWIG_fail;
	{
	array1 = obj_to_array_contiguous_allow_conversion(obj0,
	npstat::NumpyTypecode<long long >::code, &is_new_object1);
	if (!array1) SWIG_fail;
	arg1 = (long long*)array_data(array1);
	arg2 = array_dimensions(array1);
	arg3 = array_numdims(array1);
	}
	{
	try {
	result = (npstat::ArrayND< long long,1U,10U > *)npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDFromNumpy< long long >(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_long_long_1U_10U_t, SWIG_POINTER_OWN \| 0 );
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDFromNumpyFloat(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	float arg1 = (float ) 0 ;
	long arg2 = (long ) 0 ;
	int arg3 ;
	PyArrayObject *array1 = NULL ;
	int is_new_object1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< float,1U,10U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:arrayNDFromNumpyFloat",&obj0)) SWIG_fail;
	{
	array1 = obj_to_array_contiguous_allow_conversion(obj0,
	npstat::NumpyTypecode<float >::code, &is_new_object1);
	if (!array1) SWIG_fail;
	arg1 = (float*)array_data(array1);
	arg2 = array_dimensions(array1);
	arg3 = array_numdims(array1);
	}
	{
	try {
	result = (npstat::ArrayND< float,1U,10U > *)npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDFromNumpy< float >(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, SWIG_POINTER_OWN \| 0 );
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDFromNumpyDouble(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 = (double ) 0 ;
	long arg2 = (long ) 0 ;
	int arg3 ;
	PyArrayObject *array1 = NULL ;
	int is_new_object1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< double,1U,10U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:arrayNDFromNumpyDouble",&obj0)) SWIG_fail;
	{
	array1 = obj_to_array_contiguous_allow_conversion(obj0,
	npstat::NumpyTypecode<double >::code, &is_new_object1);
	if (!array1) SWIG_fail;
	arg1 = (double*)array_data(array1);
	arg2 = array_dimensions(array1);
	arg3 = array_numdims(array1);
	}
	{
	try {
	result = (npstat::ArrayND< double,1U,10U > *)npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDFromNumpy< double >(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, SWIG_POINTER_OWN \| 0 );
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDFromNumpyCFloat(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::complex< float > arg1 = (std::complex< float > ) 0 ;
	long arg2 = (long ) 0 ;
	int arg3 ;
	PyArrayObject *array1 = NULL ;
	int is_new_object1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< std::complex< float >,1U,10U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:arrayNDFromNumpyCFloat",&obj0)) SWIG_fail;
	{
	array1 = obj_to_array_contiguous_allow_conversion(obj0,
	npstat::NumpyTypecode<std::complex<float> >::code, &is_new_object1);
	if (!array1) SWIG_fail;
	arg1 = (std::complex<float>*)array_data(array1);
	arg2 = array_dimensions(array1);
	arg3 = array_numdims(array1);
	}
	{
	try {
	result = (npstat::ArrayND< std::complex< float >,1U,10U > *)npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDFromNumpy< std::complex< float > >(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_std__complexT_float_t_1U_10U_t, SWIG_POINTER_OWN \| 0 );
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDFromNumpyCDouble(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::complex< double > arg1 = (std::complex< double > ) 0 ;
	long arg2 = (long ) 0 ;
	int arg3 ;
	PyArrayObject *array1 = NULL ;
	int is_new_object1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::ArrayND< std::complex< double >,1U,10U > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:arrayNDFromNumpyCDouble",&obj0)) SWIG_fail;
	{
	array1 = obj_to_array_contiguous_allow_conversion(obj0,
	npstat::NumpyTypecode<std::complex<double> >::code, &is_new_object1);
	if (!array1) SWIG_fail;
	arg1 = (std::complex<double>*)array_data(array1);
	arg2 = array_dimensions(array1);
	arg3 = array_numdims(array1);
	}
	{
	try {
	result = (npstat::ArrayND< std::complex< double >,1U,10U > *)npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDFromNumpy< std::complex< double > >(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__ArrayNDT_std__complexT_double_t_1U_10U_t, SWIG_POINTER_OWN \| 0 );
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_matrixFromNumpy(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double arg1 = (double ) 0 ;
	long arg2 = (long ) 0 ;
	int arg3 ;
	PyArrayObject *array1 = NULL ;
	int is_new_object1 = 0 ;
	PyObject * obj0 = 0 ;
	npstat::Matrix< double,16 > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:matrixFromNumpy",&obj0)) SWIG_fail;
	{
	array1 = obj_to_array_contiguous_allow_conversion(obj0,
	npstat::NumpyTypecode<double >::code, &is_new_object1);
	if (!array1) SWIG_fail;
	arg1 = (double*)array_data(array1);
	arg2 = array_dimensions(array1);
	arg3 = array_numdims(array1);
	}
	{
	try {
	result = (npstat::Matrix< double,16 > *)npstat::SWIGTEMPLATEDISAMBIGUATOR matrixFromNumpy< double >(arg1,arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__MatrixT_double_16_t, SWIG_POINTER_OWN \| 0 );
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return resultobj;
	fail:
	{
	if (is_new_object1 && array1)
	{
	Py_DECREF(array1);
	}
	}
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoOutline1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoOutline1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< int,npstat::HistoAxis > >((npstat::HistoND< int,npstat::HistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::HistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoOutline1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< int,npstat::HistoAxis > >((npstat::HistoND< int,npstat::HistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoOutline1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoOutline1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< long long,npstat::HistoAxis > >((npstat::HistoND< long long,npstat::HistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::HistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoOutline1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< long long,npstat::HistoAxis > >((npstat::HistoND< long long,npstat::HistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoOutline1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoOutline1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< float,npstat::HistoAxis > >((npstat::HistoND< float,npstat::HistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::HistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoOutline1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< float,npstat::HistoAxis > >((npstat::HistoND< float,npstat::HistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoOutline1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoOutline1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< double,npstat::HistoAxis > >((npstat::HistoND< double,npstat::HistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::HistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoOutline1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< double,npstat::HistoAxis > >((npstat::HistoND< double,npstat::HistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoOutline1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoOutline1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< unsigned char,npstat::HistoAxis > >((npstat::HistoND< unsigned char,npstat::HistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::HistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoOutline1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< unsigned char,npstat::HistoAxis > >((npstat::HistoND< unsigned char,npstat::HistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_12(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoOutline1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoOutline1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< int,npstat::NUHistoAxis > >((npstat::HistoND< int,npstat::NUHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_13(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::NUHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoOutline1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< int,npstat::NUHistoAxis > >((npstat::HistoND< int,npstat::NUHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_14(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoOutline1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoOutline1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< long long,npstat::NUHistoAxis > >((npstat::HistoND< long long,npstat::NUHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_15(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::NUHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoOutline1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< long long,npstat::NUHistoAxis > >((npstat::HistoND< long long,npstat::NUHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_16(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoOutline1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoOutline1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< float,npstat::NUHistoAxis > >((npstat::HistoND< float,npstat::NUHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_17(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::NUHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoOutline1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< float,npstat::NUHistoAxis > >((npstat::HistoND< float,npstat::NUHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_18(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoOutline1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoOutline1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< double,npstat::NUHistoAxis > >((npstat::HistoND< double,npstat::NUHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_19(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::NUHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoOutline1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< double,npstat::NUHistoAxis > >((npstat::HistoND< double,npstat::NUHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_20(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoOutline1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoOutline1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< unsigned char,npstat::NUHistoAxis > >((npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_21(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::NUHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoOutline1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< unsigned char,npstat::NUHistoAxis > >((npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_22(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoOutline1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoOutline1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< int,npstat::DualHistoAxis > >((npstat::HistoND< int,npstat::DualHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_23(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::DualHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoOutline1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< int,npstat::DualHistoAxis > >((npstat::HistoND< int,npstat::DualHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_24(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoOutline1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoOutline1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< long long,npstat::DualHistoAxis > >((npstat::HistoND< long long,npstat::DualHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_25(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::DualHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoOutline1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< long long,npstat::DualHistoAxis > >((npstat::HistoND< long long,npstat::DualHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_26(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoOutline1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoOutline1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< float,npstat::DualHistoAxis > >((npstat::HistoND< float,npstat::DualHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_27(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::DualHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoOutline1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< float,npstat::DualHistoAxis > >((npstat::HistoND< float,npstat::DualHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_28(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoOutline1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoOutline1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< double,npstat::DualHistoAxis > >((npstat::HistoND< double,npstat::DualHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_29(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::DualHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoOutline1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< double,npstat::DualHistoAxis > >((npstat::HistoND< double,npstat::DualHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_30(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoOutline1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoOutline1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< unsigned char,npstat::DualHistoAxis > >((npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D__SWIG_31(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::DualHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoOutline1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoOutline1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoOutline1D< npstat::HistoND< unsigned char,npstat::DualHistoAxis > >((npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoOutline1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoOutline1D__SWIG_3(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoOutline1D__SWIG_5(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoOutline1D__SWIG_7(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoOutline1D__SWIG_9(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoOutline1D__SWIG_11(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoOutline1D__SWIG_13(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoOutline1D__SWIG_15(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoOutline1D__SWIG_17(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoOutline1D__SWIG_19(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoOutline1D__SWIG_21(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoOutline1D__SWIG_23(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoOutline1D__SWIG_25(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoOutline1D__SWIG_27(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoOutline1D__SWIG_29(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoOutline1D__SWIG_31(self, args);
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoOutline1D__SWIG_2(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoOutline1D__SWIG_18(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoOutline1D__SWIG_10(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoOutline1D__SWIG_20(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoOutline1D__SWIG_6(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoOutline1D__SWIG_22(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoOutline1D__SWIG_12(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoOutline1D__SWIG_24(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoOutline1D__SWIG_4(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoOutline1D__SWIG_26(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoOutline1D__SWIG_14(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoOutline1D__SWIG_28(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoOutline1D__SWIG_8(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoOutline1D__SWIG_30(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoOutline1D__SWIG_16(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'histoOutline1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::histoOutline1D< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &,double const)\n"
	" npstat::histoOutline1D< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &)\n"
	" npstat::histoOutline1D< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &,double const)\n"
	" npstat::histoOutline1D< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &)\n"
	" npstat::histoOutline1D< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &,double const)\n"
	" npstat::histoOutline1D< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &)\n"
	" npstat::histoOutline1D< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &,double const)\n"
	" npstat::histoOutline1D< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &)\n"
	" npstat::histoOutline1D< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &,double const)\n"
	" npstat::histoOutline1D< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &)\n"
	" npstat::histoOutline1D< npstat::HistoND< int,npstat::NUHistoAxis > >(npstat::HistoND< int,npstat::NUHistoAxis > const &,double const)\n"
	" npstat::histoOutline1D< npstat::HistoND< int,npstat::NUHistoAxis > >(npstat::HistoND< int,npstat::NUHistoAxis > const &)\n"
	" npstat::histoOutline1D< npstat::HistoND< long long,npstat::NUHistoAxis > >(npstat::HistoND< long long,npstat::NUHistoAxis > const &,double const)\n"
	" npstat::histoOutline1D< npstat::HistoND< long long,npstat::NUHistoAxis > >(npstat::HistoND< long long,npstat::NUHistoAxis > const &)\n"
	" npstat::histoOutline1D< npstat::HistoND< float,npstat::NUHistoAxis > >(npstat::HistoND< float,npstat::NUHistoAxis > const &,double const)\n"
	" npstat::histoOutline1D< npstat::HistoND< float,npstat::NUHistoAxis > >(npstat::HistoND< float,npstat::NUHistoAxis > const &)\n"
	" npstat::histoOutline1D< npstat::HistoND< double,npstat::NUHistoAxis > >(npstat::HistoND< double,npstat::NUHistoAxis > const &,double const)\n"
	" npstat::histoOutline1D< npstat::HistoND< double,npstat::NUHistoAxis > >(npstat::HistoND< double,npstat::NUHistoAxis > const &)\n"
	" npstat::histoOutline1D< npstat::HistoND< unsigned char,npstat::NUHistoAxis > >(npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &,double const)\n"
	" npstat::histoOutline1D< npstat::HistoND< unsigned char,npstat::NUHistoAxis > >(npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &)\n"
	" npstat::histoOutline1D< npstat::HistoND< int,npstat::DualHistoAxis > >(npstat::HistoND< int,npstat::DualHistoAxis > const &,double const)\n"
	" npstat::histoOutline1D< npstat::HistoND< int,npstat::DualHistoAxis > >(npstat::HistoND< int,npstat::DualHistoAxis > const &)\n"
	" npstat::histoOutline1D< npstat::HistoND< long long,npstat::DualHistoAxis > >(npstat::HistoND< long long,npstat::DualHistoAxis > const &,double const)\n"
	" npstat::histoOutline1D< npstat::HistoND< long long,npstat::DualHistoAxis > >(npstat::HistoND< long long,npstat::DualHistoAxis > const &)\n"
	" npstat::histoOutline1D< npstat::HistoND< float,npstat::DualHistoAxis > >(npstat::HistoND< float,npstat::DualHistoAxis > const &,double const)\n"
	" npstat::histoOutline1D< npstat::HistoND< float,npstat::DualHistoAxis > >(npstat::HistoND< float,npstat::DualHistoAxis > const &)\n"
	" npstat::histoOutline1D< npstat::HistoND< double,npstat::DualHistoAxis > >(npstat::HistoND< double,npstat::DualHistoAxis > const &,double const)\n"
	" npstat::histoOutline1D< npstat::HistoND< double,npstat::DualHistoAxis > >(npstat::HistoND< double,npstat::DualHistoAxis > const &)\n"
	" npstat::histoOutline1D< npstat::HistoND< unsigned char,npstat::DualHistoAxis > >(npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &,double const)\n"
	" npstat::histoOutline1D< npstat::HistoND< unsigned char,npstat::DualHistoAxis > >(npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoBinContents1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBinContents1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< int,npstat::HistoAxis > >((npstat::HistoND< int,npstat::HistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::HistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoBinContents1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< int,npstat::HistoAxis > >((npstat::HistoND< int,npstat::HistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoBinContents1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBinContents1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< long long,npstat::HistoAxis > >((npstat::HistoND< long long,npstat::HistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::HistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoBinContents1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< long long,npstat::HistoAxis > >((npstat::HistoND< long long,npstat::HistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoBinContents1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBinContents1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< float,npstat::HistoAxis > >((npstat::HistoND< float,npstat::HistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::HistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoBinContents1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< float,npstat::HistoAxis > >((npstat::HistoND< float,npstat::HistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoBinContents1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBinContents1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< double,npstat::HistoAxis > >((npstat::HistoND< double,npstat::HistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::HistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoBinContents1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< double,npstat::HistoAxis > >((npstat::HistoND< double,npstat::HistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoBinContents1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBinContents1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< unsigned char,npstat::HistoAxis > >((npstat::HistoND< unsigned char,npstat::HistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::HistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoBinContents1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::HistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< unsigned char,npstat::HistoAxis > >((npstat::HistoND< unsigned char,npstat::HistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_12(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoBinContents1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBinContents1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< int,npstat::NUHistoAxis > >((npstat::HistoND< int,npstat::NUHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_13(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::NUHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoBinContents1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< int,npstat::NUHistoAxis > >((npstat::HistoND< int,npstat::NUHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_14(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoBinContents1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBinContents1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< long long,npstat::NUHistoAxis > >((npstat::HistoND< long long,npstat::NUHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_15(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::NUHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoBinContents1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< long long,npstat::NUHistoAxis > >((npstat::HistoND< long long,npstat::NUHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_16(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoBinContents1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBinContents1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< float,npstat::NUHistoAxis > >((npstat::HistoND< float,npstat::NUHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_17(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::NUHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoBinContents1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< float,npstat::NUHistoAxis > >((npstat::HistoND< float,npstat::NUHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_18(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoBinContents1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBinContents1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< double,npstat::NUHistoAxis > >((npstat::HistoND< double,npstat::NUHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_19(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::NUHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoBinContents1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< double,npstat::NUHistoAxis > >((npstat::HistoND< double,npstat::NUHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_20(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::NUHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoBinContents1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::NUHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBinContents1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< unsigned char,npstat::NUHistoAxis > >((npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_21(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::NUHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoBinContents1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__NUHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::NUHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< unsigned char,npstat::NUHistoAxis > >((npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_22(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoBinContents1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBinContents1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< int,npstat::DualHistoAxis > >((npstat::HistoND< int,npstat::DualHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_23(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::DualHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoBinContents1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< int,npstat::DualHistoAxis > >((npstat::HistoND< int,npstat::DualHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_24(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoBinContents1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBinContents1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< long long,npstat::DualHistoAxis > >((npstat::HistoND< long long,npstat::DualHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_25(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::DualHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoBinContents1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< long long,npstat::DualHistoAxis > >((npstat::HistoND< long long,npstat::DualHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_26(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoBinContents1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBinContents1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< float,npstat::DualHistoAxis > >((npstat::HistoND< float,npstat::DualHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_27(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::DualHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoBinContents1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< float,npstat::DualHistoAxis > >((npstat::HistoND< float,npstat::DualHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_28(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoBinContents1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBinContents1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< double,npstat::DualHistoAxis > >((npstat::HistoND< double,npstat::DualHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_29(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::DualHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoBinContents1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< double,npstat::DualHistoAxis > >((npstat::HistoND< double,npstat::DualHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_30(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::DualHistoAxis > *arg1 = 0 ;
	double arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:histoBinContents1D",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::DualHistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "histoBinContents1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< unsigned char,npstat::DualHistoAxis > >((npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D__SWIG_31(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::DualHistoAxis > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:histoBinContents1D",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__DualHistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "histoBinContents1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::DualHistoAxis > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR histoBinContents1D< npstat::HistoND< unsigned char,npstat::DualHistoAxis > >((npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_histoBinContents1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_3(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_5(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_7(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_9(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_11(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_13(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_15(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_17(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_19(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_21(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_23(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_25(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_27(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_29(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_31(self, args);
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_2(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_18(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_10(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_20(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_6(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_22(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_12(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_24(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_4(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_26(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_14(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_28(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_8(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_30(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_histoBinContents1D__SWIG_16(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'histoBinContents1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::histoBinContents1D< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &,double const)\n"
	" npstat::histoBinContents1D< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &)\n"
	" npstat::histoBinContents1D< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &,double const)\n"
	" npstat::histoBinContents1D< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &)\n"
	" npstat::histoBinContents1D< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &,double const)\n"
	" npstat::histoBinContents1D< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &)\n"
	" npstat::histoBinContents1D< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &,double const)\n"
	" npstat::histoBinContents1D< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &)\n"
	" npstat::histoBinContents1D< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &,double const)\n"
	" npstat::histoBinContents1D< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &)\n"
	" npstat::histoBinContents1D< npstat::HistoND< int,npstat::NUHistoAxis > >(npstat::HistoND< int,npstat::NUHistoAxis > const &,double const)\n"
	" npstat::histoBinContents1D< npstat::HistoND< int,npstat::NUHistoAxis > >(npstat::HistoND< int,npstat::NUHistoAxis > const &)\n"
	" npstat::histoBinContents1D< npstat::HistoND< long long,npstat::NUHistoAxis > >(npstat::HistoND< long long,npstat::NUHistoAxis > const &,double const)\n"
	" npstat::histoBinContents1D< npstat::HistoND< long long,npstat::NUHistoAxis > >(npstat::HistoND< long long,npstat::NUHistoAxis > const &)\n"
	" npstat::histoBinContents1D< npstat::HistoND< float,npstat::NUHistoAxis > >(npstat::HistoND< float,npstat::NUHistoAxis > const &,double const)\n"
	" npstat::histoBinContents1D< npstat::HistoND< float,npstat::NUHistoAxis > >(npstat::HistoND< float,npstat::NUHistoAxis > const &)\n"
	" npstat::histoBinContents1D< npstat::HistoND< double,npstat::NUHistoAxis > >(npstat::HistoND< double,npstat::NUHistoAxis > const &,double const)\n"
	" npstat::histoBinContents1D< npstat::HistoND< double,npstat::NUHistoAxis > >(npstat::HistoND< double,npstat::NUHistoAxis > const &)\n"
	" npstat::histoBinContents1D< npstat::HistoND< unsigned char,npstat::NUHistoAxis > >(npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &,double const)\n"
	" npstat::histoBinContents1D< npstat::HistoND< unsigned char,npstat::NUHistoAxis > >(npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &)\n"
	" npstat::histoBinContents1D< npstat::HistoND< int,npstat::DualHistoAxis > >(npstat::HistoND< int,npstat::DualHistoAxis > const &,double const)\n"
	" npstat::histoBinContents1D< npstat::HistoND< int,npstat::DualHistoAxis > >(npstat::HistoND< int,npstat::DualHistoAxis > const &)\n"
	" npstat::histoBinContents1D< npstat::HistoND< long long,npstat::DualHistoAxis > >(npstat::HistoND< long long,npstat::DualHistoAxis > const &,double const)\n"
	" npstat::histoBinContents1D< npstat::HistoND< long long,npstat::DualHistoAxis > >(npstat::HistoND< long long,npstat::DualHistoAxis > const &)\n"
	" npstat::histoBinContents1D< npstat::HistoND< float,npstat::DualHistoAxis > >(npstat::HistoND< float,npstat::DualHistoAxis > const &,double const)\n"
	" npstat::histoBinContents1D< npstat::HistoND< float,npstat::DualHistoAxis > >(npstat::HistoND< float,npstat::DualHistoAxis > const &)\n"
	" npstat::histoBinContents1D< npstat::HistoND< double,npstat::DualHistoAxis > >(npstat::HistoND< double,npstat::DualHistoAxis > const &,double const)\n"
	" npstat::histoBinContents1D< npstat::HistoND< double,npstat::DualHistoAxis > >(npstat::HistoND< double,npstat::DualHistoAxis > const &)\n"
	" npstat::histoBinContents1D< npstat::HistoND< unsigned char,npstat::DualHistoAxis > >(npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &,double const)\n"
	" npstat::histoBinContents1D< npstat::HistoND< unsigned char,npstat::DualHistoAxis > >(npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_scanDensity1D(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::AbsDistribution1D *arg1 = 0 ;
	double arg2 ;
	double arg3 ;
	unsigned int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:scanDensity1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__AbsDistribution1D, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scanDensity1D" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "scanDensity1D" "', argument " "1"" of type '" "npstat::AbsDistribution1D const &""'");
	}
	arg1 = reinterpret_cast< npstat::AbsDistribution1D * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scanDensity1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "scanDensity1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "scanDensity1D" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	result = (PyObject )npstat::scanDensity1D((npstat::AbsDistribution1D const &)arg1,arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_StorableNone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableNone *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_StorableNone")) SWIG_fail;
	{
	try {
	result = (npstat::StorableNone *)new npstat::StorableNone();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableNone, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StorableNone___eq__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableNone arg1 = (npstat::StorableNone ) 0 ;
	npstat::StorableNone *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:StorableNone___eq__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableNone, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StorableNone___eq__" "', argument " "1"" of type '" "npstat::StorableNone const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableNone * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__StorableNone, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StorableNone___eq__" "', argument " "2"" of type '" "npstat::StorableNone const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StorableNone___eq__" "', argument " "2"" of type '" "npstat::StorableNone const &""'");
	}
	arg2 = reinterpret_cast< npstat::StorableNone * >(argp2);
	{
	try {
	result = (bool)((npstat::StorableNone const )arg1)->operator ==((npstat::StorableNone const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StorableNone___ne__(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableNone arg1 = (npstat::StorableNone ) 0 ;
	npstat::StorableNone *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:StorableNone___ne__",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableNone, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StorableNone___ne__" "', argument " "1"" of type '" "npstat::StorableNone const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableNone * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_npstat__StorableNone, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StorableNone___ne__" "', argument " "2"" of type '" "npstat::StorableNone const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StorableNone___ne__" "', argument " "2"" of type '" "npstat::StorableNone const &""'");
	}
	arg2 = reinterpret_cast< npstat::StorableNone * >(argp2);
	{
	try {
	result = (bool)((npstat::StorableNone const )arg1)->operator !=((npstat::StorableNone const &)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StorableNone_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableNone arg1 = (npstat::StorableNone ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:StorableNone_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableNone, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StorableNone_classId" "', argument " "1"" of type '" "npstat::StorableNone const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableNone * >(argp1);
	{
	try {
	result = ((npstat::StorableNone const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StorableNone_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableNone arg1 = (npstat::StorableNone ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:StorableNone_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableNone, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StorableNone_write" "', argument " "1"" of type '" "npstat::StorableNone const *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableNone * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StorableNone_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StorableNone_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((npstat::StorableNone const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StorableNone_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":StorableNone_classname")) SWIG_fail;
	{
	try {
	result = (char *)npstat::StorableNone::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StorableNone_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":StorableNone_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)npstat::StorableNone::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StorableNone_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableNone *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:StorableNone_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StorableNone_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StorableNone_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StorableNone_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StorableNone_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (npstat::StorableNone )npstat::StorableNone::read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableNone, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_StorableNone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableNone arg1 = (npstat::StorableNone ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_StorableNone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_npstat__StorableNone, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StorableNone" "', argument " "1"" of type '" "npstat::StorableNone *""'");
	}
	arg1 = reinterpret_cast< npstat::StorableNone * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject StorableNone_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_npstat__StorableNone, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveRecord_StorableNone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableNone *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveRecord< npstat::StorableNone > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveRecord_StorableNone",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__StorableNone, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveRecord_StorableNone" "', argument " "1"" of type '" "npstat::StorableNone const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveRecord_StorableNone" "', argument " "1"" of type '" "npstat::StorableNone const &""'");
	}
	arg1 = reinterpret_cast< npstat::StorableNone * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveRecord_StorableNone" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveRecord_StorableNone" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveRecord< npstat::StorableNone > )new gs::ArchiveRecord< npstat::StorableNone >((npstat::StorableNone const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveRecordT_npstat__StorableNone_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveRecord_StorableNone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveRecord< npstat::StorableNone > arg1 = (gs::ArchiveRecord< npstat::StorableNone > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveRecord_StorableNone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveRecordT_npstat__StorableNone_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveRecord_StorableNone" "', argument " "1"" of type '" "gs::ArchiveRecord< npstat::StorableNone > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveRecord< npstat::StorableNone > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveRecord_StorableNone_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveRecordT_npstat__StorableNone_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPRecord__SWIG_74(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableNone *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveRecord< npstat::StorableNone > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPRecord",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__StorableNone, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::StorableNone const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPRecord" "', argument " "1"" of type '" "npstat::StorableNone const &""'");
	}
	arg1 = reinterpret_cast< npstat::StorableNone * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPRecord" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPRecord" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR Record< npstat::StorableNone >((npstat::StorableNone const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveRecord< npstat::StorableNone >(static_cast< const gs::ArchiveRecord< npstat::StorableNone >& >(result))), SWIGTYPE_p_gs__ArchiveRecordT_npstat__StorableNone_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_StorableNone__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< npstat::StorableNone > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_StorableNone",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_StorableNone" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_StorableNone" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_StorableNone" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< npstat::StorableNone > )new gs::Reference< npstat::StorableNone >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__StorableNone_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_StorableNone__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::StorableNone > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_StorableNone",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_StorableNone" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_StorableNone" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_StorableNone" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_StorableNone" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< npstat::StorableNone > )new gs::Reference< npstat::StorableNone >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__StorableNone_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_StorableNone__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< npstat::StorableNone > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_StorableNone",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_StorableNone" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_StorableNone" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_StorableNone" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_StorableNone" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_StorableNone" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_StorableNone" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< npstat::StorableNone > )new gs::Reference< npstat::StorableNone >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_npstat__StorableNone_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_StorableNone(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_StorableNone__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_StorableNone__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_StorableNone__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_StorableNone'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< npstat::StorableNone >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< npstat::StorableNone >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< npstat::StorableNone >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_StorableNone_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::StorableNone > arg1 = (gs::Reference< npstat::StorableNone > ) 0 ;
	unsigned long arg2 ;
	npstat::StorableNone arg3 = (npstat::StorableNone ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_StorableNone_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__StorableNone_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_StorableNone_restore" "', argument " "1"" of type '" "gs::Reference< npstat::StorableNone > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::StorableNone > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_StorableNone_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_npstat__StorableNone, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_StorableNone_restore" "', argument " "3"" of type '" "npstat::StorableNone *""'");
	}
	arg3 = reinterpret_cast< npstat::StorableNone * >(argp3);
	{
	try {
	((gs::Reference< npstat::StorableNone > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_StorableNone_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::StorableNone > arg1 = (gs::Reference< npstat::StorableNone > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableNone *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_StorableNone_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__StorableNone_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_StorableNone_retrieve" "', argument " "1"" of type '" "gs::Reference< npstat::StorableNone > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::StorableNone > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_StorableNone_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (npstat::StorableNone )gs_Reference_Sl_npstat_StorableNone_Sg__retrieve((gs::Reference< npstat::StorableNone > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_npstat__StorableNone, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_StorableNone_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::StorableNone > arg1 = (gs::Reference< npstat::StorableNone > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	npstat::StorableNone result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_StorableNone_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__StorableNone_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_StorableNone_getValue" "', argument " "1"" of type '" "gs::Reference< npstat::StorableNone > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::StorableNone > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_StorableNone_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_npstat_StorableNone_Sg__getValue((gs::Reference< npstat::StorableNone > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new npstat::StorableNone(static_cast< const npstat::StorableNone& >(result))), SWIGTYPE_p_npstat__StorableNone, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_StorableNone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< npstat::StorableNone > arg1 = (gs::Reference< npstat::StorableNone > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_StorableNone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_npstat__StorableNone_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_StorableNone" "', argument " "1"" of type '" "gs::Reference< npstat::StorableNone > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< npstat::StorableNone > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_StorableNone_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_npstat__StorableNone_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_StorableNone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableNone *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< npstat::StorableNone > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_StorableNone",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__StorableNone, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_StorableNone" "', argument " "1"" of type '" "npstat::StorableNone const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_StorableNone" "', argument " "1"" of type '" "npstat::StorableNone const &""'");
	}
	arg1 = reinterpret_cast< npstat::StorableNone * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_StorableNone" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_StorableNone" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< npstat::StorableNone > )new gs::ArchiveValueRecord< npstat::StorableNone >((npstat::StorableNone const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_npstat__StorableNone_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_StorableNone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< npstat::StorableNone > arg1 = (gs::ArchiveValueRecord< npstat::StorableNone > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_StorableNone",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_npstat__StorableNone_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_StorableNone" "', argument " "1"" of type '" "gs::ArchiveValueRecord< npstat::StorableNone > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< npstat::StorableNone > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_StorableNone_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_npstat__StorableNone_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_StorableNone(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::StorableNone *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< npstat::StorableNone > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_StorableNone",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__StorableNone, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_StorableNone" "', argument " "1"" of type '" "npstat::StorableNone const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_StorableNone" "', argument " "1"" of type '" "npstat::StorableNone const &""'");
	}
	arg1 = reinterpret_cast< npstat::StorableNone * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_StorableNone" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_StorableNone" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< npstat::StorableNone >((npstat::StorableNone const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< npstat::StorableNone >(static_cast< const gs::ArchiveValueRecord< npstat::StorableNone >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_npstat__StorableNone_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_PyObject__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Ref_PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_PyObject",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_PyObject" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_PyObject" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_PyObject" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Ref_PyObject )new gs::Ref_PyObject(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__Ref_PyObject, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_PyObject__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Ref_PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_PyObject",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_PyObject" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_PyObject" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_PyObject" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_PyObject" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Ref_PyObject )new gs::Ref_PyObject(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__Ref_PyObject, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_PyObject__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Ref_PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_PyObject",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_PyObject" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_PyObject" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_PyObject" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_PyObject" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_PyObject" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_PyObject" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Ref_PyObject )new gs::Ref_PyObject(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__Ref_PyObject, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_PyObject(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_PyObject__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_PyObject__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_PyObject__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_PyObject'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Ref_PyObject::Ref_PyObject(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Ref_PyObject::Ref_PyObject(gs::AbsArchive &,char const ,char const )\n"
	" gs::Ref_PyObject::Ref_PyObject(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_PyObject(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Ref_PyObject arg1 = (gs::Ref_PyObject ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_PyObject",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__Ref_PyObject, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_PyObject" "', argument " "1"" of type '" "gs::Ref_PyObject *""'");
	}
	arg1 = reinterpret_cast< gs::Ref_PyObject * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_PyObject_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Ref_PyObject arg1 = (gs::Ref_PyObject ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_PyObject_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__Ref_PyObject, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_PyObject_retrieve" "', argument " "1"" of type '" "gs::Ref_PyObject const *""'");
	}
	arg1 = reinterpret_cast< gs::Ref_PyObject * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_PyObject_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (PyObject )((gs::Ref_PyObject const )arg1)->retrieve(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_PyObject_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Ref_PyObject arg1 = (gs::Ref_PyObject ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_PyObject_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__Ref_PyObject, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_PyObject_getValue" "', argument " "1"" of type '" "gs::Ref_PyObject const *""'");
	}
	arg1 = reinterpret_cast< gs::Ref_PyObject * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_PyObject_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (PyObject )((gs::Ref_PyObject const )arg1)->getValue(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_PyObject_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__Ref_PyObject, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_PythonRecord__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	PyObject arg1 = (PyObject ) 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::PythonRecord *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_PythonRecord",&obj0,&obj1,&obj2)) SWIG_fail;
	arg1 = obj0;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PythonRecord" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PythonRecord" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::PythonRecord )new gs::PythonRecord(arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__PythonRecord, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_PythonRecord__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::PythonRecord *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	gs::PythonRecord *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_PythonRecord",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__PythonRecord, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PythonRecord" "', argument " "1"" of type '" "gs::PythonRecord const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PythonRecord" "', argument " "1"" of type '" "gs::PythonRecord const &""'");
	}
	arg1 = reinterpret_cast< gs::PythonRecord * >(argp1);
	{
	try {
	result = (gs::PythonRecord )new gs::PythonRecord((gs::PythonRecord const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__PythonRecord, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_PythonRecord(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gs__PythonRecord, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_PythonRecord__SWIG_1(self, args);
	}
	}
	if (argc == 3) {
	int _v;
	_v = (argv[0] != 0);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_PythonRecord__SWIG_0(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_PythonRecord'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::PythonRecord::PythonRecord(PyObject ,char const ,char const *)\n"
	" gs::PythonRecord::PythonRecord(gs::PythonRecord const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_PythonRecord(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::PythonRecord arg1 = (gs::PythonRecord ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_PythonRecord",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__PythonRecord, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PythonRecord" "', argument " "1"" of type '" "gs::PythonRecord *""'");
	}
	arg1 = reinterpret_cast< gs::PythonRecord * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject PythonRecord_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__PythonRecord, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPRecord__SWIG_75(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	PyObject arg1 = (PyObject ) 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::PythonRecord > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPRecord",&obj0,&obj1,&obj2)) SWIG_fail;
	arg1 = obj0;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPRecord" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPRecord" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::NPRecord(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::PythonRecord(static_cast< const gs::PythonRecord& >(result))), SWIGTYPE_p_gs__PythonRecord, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_StringArchive__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char arg1 = (char ) 0 ;
	int res1 ;
	char *buf1 = 0 ;
	int alloc1 = 0 ;
	PyObject * obj0 = 0 ;
	gs::StringArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:new_StringArchive",&obj0)) SWIG_fail;
	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StringArchive" "', argument " "1"" of type '" "char const *""'");
	}
	arg1 = reinterpret_cast< char * >(buf1);
	{
	try {
	result = (gs::StringArchive )new gs::StringArchive((char const )arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__StringArchive, SWIG_POINTER_NEW \| 0 );
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	return resultobj;
	fail:
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_StringArchive__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":new_StringArchive")) SWIG_fail;
	{
	try {
	result = (gs::StringArchive *)new gs::StringArchive();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__StringArchive, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_StringArchive(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[2] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 1) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 0) {
	return _wrap_new_StringArchive__SWIG_1(self, args);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_StringArchive__SWIG_0(self, args);
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_StringArchive'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::StringArchive::StringArchive(char const *)\n"
	" gs::StringArchive::StringArchive()\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_StringArchive(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive arg1 = (gs::StringArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_StringArchive",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__StringArchive, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringArchive" "', argument " "1"" of type '" "gs::StringArchive *""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_isOpen(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive arg1 = (gs::StringArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:StringArchive_isOpen",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__StringArchive, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringArchive_isOpen" "', argument " "1"" of type '" "gs::StringArchive const *""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	{
	try {
	result = (bool)((gs::StringArchive const *)arg1)->isOpen();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_error(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive arg1 = (gs::StringArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::string result;

	if (!PyArg_ParseTuple(args,(char *)"O:StringArchive_error",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__StringArchive, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringArchive_error" "', argument " "1"" of type '" "gs::StringArchive const *""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	{
	try {
	result = ((gs::StringArchive const *)arg1)->error();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_isReadable(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive arg1 = (gs::StringArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:StringArchive_isReadable",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__StringArchive, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringArchive_isReadable" "', argument " "1"" of type '" "gs::StringArchive const *""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	{
	try {
	result = (bool)((gs::StringArchive const *)arg1)->isReadable();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_isWritable(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive arg1 = (gs::StringArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:StringArchive_isWritable",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__StringArchive, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringArchive_isWritable" "', argument " "1"" of type '" "gs::StringArchive const *""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	{
	try {
	result = (bool)((gs::StringArchive const *)arg1)->isWritable();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_size(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive arg1 = (gs::StringArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long long result;

	if (!PyArg_ParseTuple(args,(char *)"O:StringArchive_size",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__StringArchive, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringArchive_size" "', argument " "1"" of type '" "gs::StringArchive const *""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	{
	try {
	result = (unsigned long long)((gs::StringArchive const *)arg1)->size();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_smallestId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive arg1 = (gs::StringArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long long result;

	if (!PyArg_ParseTuple(args,(char *)"O:StringArchive_smallestId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__StringArchive, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringArchive_smallestId" "', argument " "1"" of type '" "gs::StringArchive const *""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	{
	try {
	result = (unsigned long long)((gs::StringArchive const *)arg1)->smallestId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_largestId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive arg1 = (gs::StringArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long long result;

	if (!PyArg_ParseTuple(args,(char *)"O:StringArchive_largestId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__StringArchive, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringArchive_largestId" "', argument " "1"" of type '" "gs::StringArchive const *""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	{
	try {
	result = (unsigned long long)((gs::StringArchive const *)arg1)->largestId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_idsAreContiguous(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive arg1 = (gs::StringArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:StringArchive_idsAreContiguous",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__StringArchive, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringArchive_idsAreContiguous" "', argument " "1"" of type '" "gs::StringArchive const *""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	{
	try {
	result = (bool)((gs::StringArchive const *)arg1)->idsAreContiguous();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_itemExists(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive arg1 = (gs::StringArchive ) 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:StringArchive_itemExists",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__StringArchive, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringArchive_itemExists" "', argument " "1"" of type '" "gs::StringArchive const *""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringArchive_itemExists" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (bool)((gs::StringArchive const *)arg1)->itemExists(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_itemSearch(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive arg1 = (gs::StringArchive ) 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	std::vector< unsigned long long,std::allocator< unsigned long long > > arg4 = (std::vector< unsigned long long,std::allocator< unsigned long long > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:StringArchive_itemSearch",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__StringArchive, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringArchive_itemSearch" "', argument " "1"" of type '" "gs::StringArchive const *""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringArchive_itemSearch" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringArchive_itemSearch" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringArchive_itemSearch" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringArchive_itemSearch" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_std__vectorT_unsigned_long_long_std__allocatorT_unsigned_long_long_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringArchive_itemSearch" "', argument " "4"" of type '" "std::vector< unsigned long long,std::allocator< unsigned long long > > *""'");
	}
	arg4 = reinterpret_cast< std::vector< unsigned long long,std::allocator< unsigned long long > > * >(argp4);
	{
	try {
	((gs::StringArchive const )arg1)->itemSearch((gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)*arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_flush(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive arg1 = (gs::StringArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:StringArchive_flush",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__StringArchive, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringArchive_flush" "', argument " "1"" of type '" "gs::StringArchive *""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	{
	try {
	(arg1)->flush();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_str(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive arg1 = (gs::StringArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::string result;

	if (!PyArg_ParseTuple(args,(char *)"O:StringArchive_str",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__StringArchive, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringArchive_str" "', argument " "1"" of type '" "gs::StringArchive const *""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	{
	try {
	result = ((gs::StringArchive const *)arg1)->str();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_dataSize(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive arg1 = (gs::StringArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"O:StringArchive_dataSize",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__StringArchive, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringArchive_dataSize" "', argument " "1"" of type '" "gs::StringArchive const *""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	{
	try {
	result = (unsigned long)((gs::StringArchive const *)arg1)->dataSize();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_classId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive arg1 = (gs::StringArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	SwigValueWrapper< gs::ClassId > result;

	if (!PyArg_ParseTuple(args,(char *)"O:StringArchive_classId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__StringArchive, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringArchive_classId" "', argument " "1"" of type '" "gs::StringArchive const *""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	{
	try {
	result = ((gs::StringArchive const *)arg1)->classId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ClassId(static_cast< const gs::ClassId& >(result))), SWIGTYPE_p_gs__ClassId, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_write(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive arg1 = (gs::StringArchive ) 0 ;
	std::ostream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:StringArchive_write",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__StringArchive, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringArchive_write" "', argument " "1"" of type '" "gs::StringArchive const *""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringArchive_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringArchive_write" "', argument " "2"" of type '" "std::ostream &""'");
	}
	arg2 = reinterpret_cast< std::ostream * >(argp2);
	{
	try {
	result = (bool)((gs::StringArchive const )arg1)->write(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_classname(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)":StringArchive_classname")) SWIG_fail;
	{
	try {
	result = (char *)gs::StringArchive::classname();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)":StringArchive_version")) SWIG_fail;
	{
	try {
	result = (unsigned int)gs::StringArchive::version();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_StringArchive_read(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ClassId *arg1 = 0 ;
	std::istream *arg2 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::StringArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:StringArchive_read",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__ClassId, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringArchive_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringArchive_read" "', argument " "1"" of type '" "gs::ClassId const &""'");
	}
	arg1 = reinterpret_cast< gs::ClassId * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0 );
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringArchive_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringArchive_read" "', argument " "2"" of type '" "std::istream &""'");
	}
	arg2 = reinterpret_cast< std::istream * >(argp2);
	{
	try {
	result = (gs::StringArchive )gs::StringArchive::read((gs::ClassId const &)arg1,*arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__StringArchive, 0 \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject StringArchive_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__StringArchive, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveRecord_StringArchive(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveRecord< gs::StringArchive > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveRecord_StringArchive",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__StringArchive, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveRecord_StringArchive" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveRecord_StringArchive" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveRecord_StringArchive" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveRecord_StringArchive" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveRecord< gs::StringArchive > )new gs::ArchiveRecord< gs::StringArchive >((gs::StringArchive const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveRecordT_gs__StringArchive_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveRecord_StringArchive(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveRecord< gs::StringArchive > arg1 = (gs::ArchiveRecord< gs::StringArchive > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveRecord_StringArchive",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveRecordT_gs__StringArchive_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveRecord_StringArchive" "', argument " "1"" of type '" "gs::ArchiveRecord< gs::StringArchive > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveRecord< gs::StringArchive > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveRecord_StringArchive_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveRecordT_gs__StringArchive_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPRecord__SWIG_76(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveRecord< gs::StringArchive > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPRecord",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__StringArchive, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPRecord" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPRecord" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPRecord" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPRecord" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR Record< gs::StringArchive >((gs::StringArchive const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveRecord< gs::StringArchive >(static_cast< const gs::ArchiveRecord< gs::StringArchive >& >(result))), SWIGTYPE_p_gs__ArchiveRecordT_gs__StringArchive_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_NPRecord(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoxNDT_unsigned_char_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_0(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoxNDT_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_1(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoxNDT_long_long_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoxNDT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoxNDT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_4(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BoxNDT_unsigned_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_5(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_npstat__StatAccumulator_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_6(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_npstat__WeightedStatAccumulator_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_7(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_npstat__SampleAccumulatorT_float_long_double_t_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_8(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_npstat__SampleAccumulatorT_double_long_double_t_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_9(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_npstat__WeightedSampleAccumulatorT_double_long_double_t_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_10(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_npstat__BinSummary_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_11(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_unsigned_char_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_12(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_int_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_13(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_long_long_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_14(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_15(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_16(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_std__complexT_float_t_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_17(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_std__complexT_double_t_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_18(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_19(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_20(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_21(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_22(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_23(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_24(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_25(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_26(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_27(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_28(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_29(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_30(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_31(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_32(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_33(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__StatAccumulator_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_34(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__StatAccumulator_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_35(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__StatAccumulator_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_36(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__WeightedStatAccumulator_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_37(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__WeightedStatAccumulator_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_38(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__WeightedStatAccumulator_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_39(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__BinSummary_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_40(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__BinSummary_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_41(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__BinSummary_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_42(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__SampleAccumulatorT_float_long_double_t_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_43(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__SampleAccumulatorT_float_long_double_t_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_44(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__SampleAccumulatorT_float_long_double_t_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_45(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__SampleAccumulatorT_double_long_double_t_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_46(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__SampleAccumulatorT_double_long_double_t_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_47(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__SampleAccumulatorT_double_long_double_t_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_48(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__WeightedSampleAccumulatorT_double_long_double_t_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_49(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__WeightedSampleAccumulatorT_double_long_double_t_npstat__NUHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_50(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_npstat__WeightedSampleAccumulatorT_double_long_double_t_npstat__DualHistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_51(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__Tabulated1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_54(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__DiscreteTabulated1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_71(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__BinnedDensity1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_55(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_52(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDistributionND, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_56(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__MatrixT_float_16_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_57(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__MatrixT_double_16_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_58(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__MatrixT_long_double_16_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_59(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__InMemoryNtupleT_unsigned_char_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_60(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__InMemoryNtupleT_int_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_61(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__InMemoryNtupleT_long_long_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_62(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__InMemoryNtupleT_float_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_63(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__InMemoryNtupleT_double_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_64(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_65(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_66(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_double_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_67(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__UniformAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_68(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__GridAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_69(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__LinInterpolatedTableNDT_float_npstat__DualAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_70(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__Poisson1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_72(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__AbsDiscreteDistribution1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_53(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__LinInterpolatedTable1D, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_73(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__StorableNone, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_74(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gs__StringArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_76(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	_v = (argv[0] != 0);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_NPRecord__SWIG_75(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'NPRecord'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Record< npstat::BoxND< unsigned char > >(npstat::BoxND< unsigned char > const &,char const ,char const )\n"
	" gs::Record< npstat::BoxND< int > >(npstat::BoxND< int > const &,char const ,char const )\n"
	" gs::Record< npstat::BoxND< long long > >(npstat::BoxND< long long > const &,char const ,char const )\n"
	" gs::Record< npstat::BoxND< float > >(npstat::BoxND< float > const &,char const ,char const )\n"
	" gs::Record< npstat::BoxND< double > >(npstat::BoxND< double > const &,char const ,char const )\n"
	" gs::Record< npstat::BoxND< unsigned int > >(npstat::BoxND< unsigned int > const &,char const ,char const )\n"
	" gs::Record< npstat::ArrayND< npstat::StatAccumulator > >(npstat::ArrayND< npstat::StatAccumulator,1U,10U > const &,char const ,char const )\n"
	" gs::Record< npstat::ArrayND< npstat::WeightedStatAccumulator > >(npstat::ArrayND< npstat::WeightedStatAccumulator,1U,10U > const &,char const ,char const )\n"
	" gs::Record< npstat::ArrayND< npstat::FloatSampleAccumulator > >(npstat::ArrayND< npstat::FloatSampleAccumulator,1U,10U > const &,char const ,char const )\n"
	" gs::Record< npstat::ArrayND< npstat::DoubleSampleAccumulator > >(npstat::ArrayND< npstat::DoubleSampleAccumulator,1U,10U > const &,char const ,char const )\n"
	" gs::Record< npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator > >(npstat::ArrayND< npstat::DoubleWeightedSampleAccumulator,1U,10U > const &,char const ,char const )\n"
	" gs::Record< npstat::ArrayND< npstat::BinSummary > >(npstat::ArrayND< npstat::BinSummary,1U,10U > const &,char const ,char const )\n"
	" gs::Record< npstat::ArrayND< unsigned char > >(npstat::ArrayND< unsigned char,1U,10U > const &,char const ,char const )\n"
	" gs::Record< npstat::ArrayND< int > >(npstat::ArrayND< int,1U,10U > const &,char const ,char const )\n"
	" gs::Record< npstat::ArrayND< long long > >(npstat::ArrayND< long long,1U,10U > const &,char const ,char const )\n"
	" gs::Record< npstat::ArrayND< float > >(npstat::ArrayND< float,1U,10U > const &,char const ,char const )\n"
	" gs::Record< npstat::ArrayND< double > >(npstat::ArrayND< double,1U,10U > const &,char const ,char const )\n"
	" gs::Record< npstat::ArrayND< std::complex< float > > >(npstat::ArrayND< std::complex< float >,1U,10U > const &,char const ,char const )\n"
	" gs::Record< npstat::ArrayND< std::complex< double > > >(npstat::ArrayND< std::complex< double >,1U,10U > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< unsigned char,npstat::NUHistoAxis > >(npstat::HistoND< unsigned char,npstat::NUHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< unsigned char,npstat::DualHistoAxis > >(npstat::HistoND< unsigned char,npstat::DualHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< int,npstat::NUHistoAxis > >(npstat::HistoND< int,npstat::NUHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< int,npstat::DualHistoAxis > >(npstat::HistoND< int,npstat::DualHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< long long,npstat::NUHistoAxis > >(npstat::HistoND< long long,npstat::NUHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< long long,npstat::DualHistoAxis > >(npstat::HistoND< long long,npstat::DualHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< float,npstat::NUHistoAxis > >(npstat::HistoND< float,npstat::NUHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< float,npstat::DualHistoAxis > >(npstat::HistoND< float,npstat::DualHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< double,npstat::NUHistoAxis > >(npstat::HistoND< double,npstat::NUHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< double,npstat::DualHistoAxis > >(npstat::HistoND< double,npstat::DualHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::StatAccumulator,npstat::HistoAxis > >(npstat::HistoND< npstat::StatAccumulator,npstat::HistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::StatAccumulator,npstat::NUHistoAxis > >(npstat::HistoND< npstat::StatAccumulator,npstat::NUHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::StatAccumulator,npstat::DualHistoAxis > >(npstat::HistoND< npstat::StatAccumulator,npstat::DualHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::WeightedStatAccumulator,npstat::HistoAxis > >(npstat::HistoND< npstat::WeightedStatAccumulator,npstat::HistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::WeightedStatAccumulator,npstat::NUHistoAxis > >(npstat::HistoND< npstat::WeightedStatAccumulator,npstat::NUHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::WeightedStatAccumulator,npstat::DualHistoAxis > >(npstat::HistoND< npstat::WeightedStatAccumulator,npstat::DualHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::BinSummary,npstat::HistoAxis > >(npstat::HistoND< npstat::BinSummary,npstat::HistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::BinSummary,npstat::NUHistoAxis > >(npstat::HistoND< npstat::BinSummary,npstat::NUHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::BinSummary,npstat::DualHistoAxis > >(npstat::HistoND< npstat::BinSummary,npstat::DualHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::FloatSampleAccumulator,npstat::HistoAxis > >(npstat::HistoND< npstat::FloatSampleAccumulator,npstat::HistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::FloatSampleAccumulator,npstat::NUHistoAxis > >(npstat::HistoND< npstat::FloatSampleAccumulator,npstat::NUHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::FloatSampleAccumulator,npstat::DualHistoAxis > >(npstat::HistoND< npstat::FloatSampleAccumulator,npstat::DualHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::HistoAxis > >(npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::HistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::NUHistoAxis > >(npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::NUHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::DualHistoAxis > >(npstat::HistoND< npstat::DoubleSampleAccumulator,npstat::DualHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::HistoAxis > >(npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::HistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::NUHistoAxis > >(npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::NUHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::DualHistoAxis > >(npstat::HistoND< npstat::DoubleWeightedSampleAccumulator,npstat::DualHistoAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::AbsDistribution1D >(npstat::AbsDistribution1D const &,char const ,char const )\n"
	" gs::Record< npstat::AbsDiscreteDistribution1D >(npstat::AbsDiscreteDistribution1D const &,char const ,char const )\n"
	" gs::Record< npstat::Tabulated1D >(npstat::Tabulated1D const &,char const ,char const )\n"
	" gs::Record< npstat::BinnedDensity1D >(npstat::BinnedDensity1D const &,char const ,char const )\n"
	" gs::Record< npstat::AbsDistributionND >(npstat::AbsDistributionND const &,char const ,char const )\n"
	" gs::Record< npstat::Matrix< float > >(npstat::Matrix< float,16 > const &,char const ,char const )\n"
	" gs::Record< npstat::Matrix< double > >(npstat::Matrix< double,16 > const &,char const ,char const )\n"
	" gs::Record< npstat::Matrix< long double > >(npstat::Matrix< long double,16 > const &,char const ,char const )\n"
	" gs::Record< npstat::InMemoryNtuple< unsigned char > >(npstat::InMemoryNtuple< unsigned char > const &,char const ,char const )\n"
	" gs::Record< npstat::InMemoryNtuple< int > >(npstat::InMemoryNtuple< int > const &,char const ,char const )\n"
	" gs::Record< npstat::InMemoryNtuple< long long > >(npstat::InMemoryNtuple< long long > const &,char const ,char const )\n"
	" gs::Record< npstat::InMemoryNtuple< float > >(npstat::InMemoryNtuple< float > const &,char const ,char const )\n"
	" gs::Record< npstat::InMemoryNtuple< double > >(npstat::InMemoryNtuple< double > const &,char const ,char const )\n"
	" gs::Record< npstat::LinInterpolatedTableND< double,npstat::UniformAxis > >(npstat::LinInterpolatedTableND< double,npstat::UniformAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::LinInterpolatedTableND< double,npstat::GridAxis > >(npstat::LinInterpolatedTableND< double,npstat::GridAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::LinInterpolatedTableND< double,npstat::DualAxis > >(npstat::LinInterpolatedTableND< double,npstat::DualAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::LinInterpolatedTableND< float,npstat::UniformAxis > >(npstat::LinInterpolatedTableND< float,npstat::UniformAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::LinInterpolatedTableND< float,npstat::GridAxis > >(npstat::LinInterpolatedTableND< float,npstat::GridAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::LinInterpolatedTableND< float,npstat::DualAxis > >(npstat::LinInterpolatedTableND< float,npstat::DualAxis > const &,char const ,char const )\n"
	" gs::Record< npstat::DiscreteTabulated1D >(npstat::DiscreteTabulated1D const &,char const ,char const )\n"
	" gs::Record< npstat::Poisson1D >(npstat::Poisson1D const &,char const ,char const )\n"
	" gs::Record< npstat::LinInterpolatedTable1D >(npstat::LinInterpolatedTable1D const &,char const ,char const )\n"
	" gs::Record< npstat::StorableNone >(npstat::StorableNone const &,char const ,char const )\n"
	" gs::NPRecord(PyObject ,char const ,char const *)\n"
	" gs::Record< gs::StringArchive >(gs::StringArchive const &,char const ,char const )\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_stringArchiveToBinary(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:stringArchiveToBinary",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__StringArchive, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stringArchiveToBinary" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "stringArchiveToBinary" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	{
	try {
	result = (PyObject )npstat::stringArchiveToBinary((gs::StringArchive const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_stringArchiveFromBinary(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	PyObject arg1 = (PyObject ) 0 ;
	PyObject * obj0 = 0 ;
	gs::StringArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:stringArchiveFromBinary",&obj0)) SWIG_fail;
	arg1 = obj0;
	{
	try {
	result = (gs::StringArchive *)npstat::stringArchiveFromBinary(arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__StringArchive, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_lorpeSmooth1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	double arg3 ;
	npstat::BoundaryHandling *arg4 = 0 ;
	double arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:lorpeSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lorpeSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lorpeSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg4 = reinterpret_cast< npstat::BoundaryHandling * >(argp4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "lorpeSmooth1D" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR lorpeSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >((npstat::HistoND< int,npstat::HistoAxis > const &)arg1,arg2,arg3,(npstat::BoundaryHandling const &)*arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_lorpeSmooth1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	double arg3 ;
	npstat::BoundaryHandling *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:lorpeSmooth1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lorpeSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lorpeSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg4 = reinterpret_cast< npstat::BoundaryHandling * >(argp4);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR lorpeSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >((npstat::HistoND< int,npstat::HistoAxis > const &)arg1,arg2,arg3,(npstat::BoundaryHandling const &)*arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_lorpeSmooth1D__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	double arg3 ;
	npstat::BoundaryHandling *arg4 = 0 ;
	double arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:lorpeSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lorpeSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lorpeSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg4 = reinterpret_cast< npstat::BoundaryHandling * >(argp4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "lorpeSmooth1D" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR lorpeSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >((npstat::HistoND< long long,npstat::HistoAxis > const &)arg1,arg2,arg3,(npstat::BoundaryHandling const &)*arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_lorpeSmooth1D__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	double arg3 ;
	npstat::BoundaryHandling *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:lorpeSmooth1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lorpeSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lorpeSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg4 = reinterpret_cast< npstat::BoundaryHandling * >(argp4);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR lorpeSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >((npstat::HistoND< long long,npstat::HistoAxis > const &)arg1,arg2,arg3,(npstat::BoundaryHandling const &)*arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_lorpeSmooth1D__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	double arg3 ;
	npstat::BoundaryHandling *arg4 = 0 ;
	double arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:lorpeSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lorpeSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lorpeSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg4 = reinterpret_cast< npstat::BoundaryHandling * >(argp4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "lorpeSmooth1D" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR lorpeSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >((npstat::HistoND< float,npstat::HistoAxis > const &)arg1,arg2,arg3,(npstat::BoundaryHandling const &)*arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_lorpeSmooth1D__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	double arg3 ;
	npstat::BoundaryHandling *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:lorpeSmooth1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lorpeSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lorpeSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg4 = reinterpret_cast< npstat::BoundaryHandling * >(argp4);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR lorpeSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >((npstat::HistoND< float,npstat::HistoAxis > const &)arg1,arg2,arg3,(npstat::BoundaryHandling const &)*arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_lorpeSmooth1D__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	double arg3 ;
	npstat::BoundaryHandling *arg4 = 0 ;
	double arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:lorpeSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lorpeSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lorpeSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg4 = reinterpret_cast< npstat::BoundaryHandling * >(argp4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "lorpeSmooth1D" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR lorpeSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >((npstat::HistoND< double,npstat::HistoAxis > const &)arg1,arg2,arg3,(npstat::BoundaryHandling const &)*arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_lorpeSmooth1D__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	double arg3 ;
	npstat::BoundaryHandling *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:lorpeSmooth1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lorpeSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lorpeSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg4 = reinterpret_cast< npstat::BoundaryHandling * >(argp4);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR lorpeSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >((npstat::HistoND< double,npstat::HistoAxis > const &)arg1,arg2,arg3,(npstat::BoundaryHandling const &)*arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_lorpeSmooth1D__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	double arg3 ;
	npstat::BoundaryHandling *arg4 = 0 ;
	double arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	double val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:lorpeSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lorpeSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lorpeSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg4 = reinterpret_cast< npstat::BoundaryHandling * >(argp4);
	ecode5 = SWIG_AsVal_double(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "lorpeSmooth1D" "', argument " "5"" of type '" "double""'");
	}
	arg5 = static_cast< double >(val5);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR lorpeSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >((npstat::HistoND< unsigned char,npstat::HistoAxis > const &)arg1,arg2,arg3,(npstat::BoundaryHandling const &)*arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_lorpeSmooth1D__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::HistoAxis > *arg1 = 0 ;
	int arg2 ;
	double arg3 ;
	npstat::BoundaryHandling *arg4 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int val2 ;
	int ecode2 = 0 ;
	double val3 ;
	int ecode3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:lorpeSmooth1D",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_int(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lorpeSmooth1D" "', argument " "2"" of type '" "int""'");
	}
	arg2 = static_cast< int >(val2);
	ecode3 = SWIG_AsVal_double(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lorpeSmooth1D" "', argument " "3"" of type '" "double""'");
	}
	arg3 = static_cast< double >(val3);
	res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp4) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lorpeSmooth1D" "', argument " "4"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg4 = reinterpret_cast< npstat::BoundaryHandling * >(argp4);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR lorpeSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >((npstat::HistoND< unsigned char,npstat::HistoAxis > const &)arg1,arg2,arg3,(npstat::BoundaryHandling const &)*arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_lorpeSmooth1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_lorpeSmooth1D__SWIG_1(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_lorpeSmooth1D__SWIG_3(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_lorpeSmooth1D__SWIG_5(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_lorpeSmooth1D__SWIG_7(self, args);
	}
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_lorpeSmooth1D__SWIG_9(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_lorpeSmooth1D__SWIG_2(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_lorpeSmooth1D__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_lorpeSmooth1D__SWIG_0(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_lorpeSmooth1D__SWIG_8(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_lorpeSmooth1D__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'lorpeSmooth1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::lorpeSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &,int,double,npstat::BoundaryHandling const &,double)\n"
	" npstat::lorpeSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &,int,double,npstat::BoundaryHandling const &)\n"
	" npstat::lorpeSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &,int,double,npstat::BoundaryHandling const &,double)\n"
	" npstat::lorpeSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &,int,double,npstat::BoundaryHandling const &)\n"
	" npstat::lorpeSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &,int,double,npstat::BoundaryHandling const &,double)\n"
	" npstat::lorpeSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &,int,double,npstat::BoundaryHandling const &)\n"
	" npstat::lorpeSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &,int,double,npstat::BoundaryHandling const &,double)\n"
	" npstat::lorpeSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &,int,double,npstat::BoundaryHandling const &)\n"
	" npstat::lorpeSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &,int,double,npstat::BoundaryHandling const &,double)\n"
	" npstat::lorpeSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &,int,double,npstat::BoundaryHandling const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_weightedLorpeSmooth1D__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	double arg4 ;
	npstat::BoundaryHandling *arg5 = 0 ;
	double arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:weightedLorpeSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedLorpeSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedLorpeSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "weightedLorpeSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg5 = reinterpret_cast< npstat::BoundaryHandling * >(argp5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "weightedLorpeSmooth1D" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedLorpeSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >((npstat::HistoND< int,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,(npstat::BoundaryHandling const &)*arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedLorpeSmooth1D__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< int,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	double arg4 ;
	npstat::BoundaryHandling *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:weightedLorpeSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< int,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< int,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedLorpeSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedLorpeSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "weightedLorpeSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg5 = reinterpret_cast< npstat::BoundaryHandling * >(argp5);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedLorpeSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >((npstat::HistoND< int,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,(npstat::BoundaryHandling const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedLorpeSmooth1D__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	double arg4 ;
	npstat::BoundaryHandling *arg5 = 0 ;
	double arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:weightedLorpeSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedLorpeSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedLorpeSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "weightedLorpeSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg5 = reinterpret_cast< npstat::BoundaryHandling * >(argp5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "weightedLorpeSmooth1D" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedLorpeSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >((npstat::HistoND< long long,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,(npstat::BoundaryHandling const &)*arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedLorpeSmooth1D__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< long long,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	double arg4 ;
	npstat::BoundaryHandling *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:weightedLorpeSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< long long,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< long long,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedLorpeSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedLorpeSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "weightedLorpeSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg5 = reinterpret_cast< npstat::BoundaryHandling * >(argp5);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedLorpeSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >((npstat::HistoND< long long,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,(npstat::BoundaryHandling const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedLorpeSmooth1D__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	double arg4 ;
	npstat::BoundaryHandling *arg5 = 0 ;
	double arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:weightedLorpeSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedLorpeSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedLorpeSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "weightedLorpeSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg5 = reinterpret_cast< npstat::BoundaryHandling * >(argp5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "weightedLorpeSmooth1D" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedLorpeSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >((npstat::HistoND< float,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,(npstat::BoundaryHandling const &)*arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedLorpeSmooth1D__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< float,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	double arg4 ;
	npstat::BoundaryHandling *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:weightedLorpeSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< float,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< float,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedLorpeSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedLorpeSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "weightedLorpeSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg5 = reinterpret_cast< npstat::BoundaryHandling * >(argp5);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedLorpeSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >((npstat::HistoND< float,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,(npstat::BoundaryHandling const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedLorpeSmooth1D__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	double arg4 ;
	npstat::BoundaryHandling *arg5 = 0 ;
	double arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:weightedLorpeSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedLorpeSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedLorpeSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "weightedLorpeSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg5 = reinterpret_cast< npstat::BoundaryHandling * >(argp5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "weightedLorpeSmooth1D" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedLorpeSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >((npstat::HistoND< double,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,(npstat::BoundaryHandling const &)*arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedLorpeSmooth1D__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< double,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	double arg4 ;
	npstat::BoundaryHandling *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:weightedLorpeSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< double,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< double,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedLorpeSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedLorpeSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "weightedLorpeSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg5 = reinterpret_cast< npstat::BoundaryHandling * >(argp5);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedLorpeSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >((npstat::HistoND< double,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,(npstat::BoundaryHandling const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedLorpeSmooth1D__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	double arg4 ;
	npstat::BoundaryHandling *arg5 = 0 ;
	double arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	double val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:weightedLorpeSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedLorpeSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedLorpeSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "weightedLorpeSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg5 = reinterpret_cast< npstat::BoundaryHandling * >(argp5);
	ecode6 = SWIG_AsVal_double(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "weightedLorpeSmooth1D" "', argument " "6"" of type '" "double""'");
	}
	arg6 = static_cast< double >(val6);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedLorpeSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >((npstat::HistoND< unsigned char,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,(npstat::BoundaryHandling const &)*arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedLorpeSmooth1D__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::HistoND< unsigned char,npstat::HistoAxis > *arg1 = 0 ;
	double arg2 ;
	int arg3 ;
	double arg4 ;
	npstat::BoundaryHandling *arg5 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	double val2 ;
	int ecode2 = 0 ;
	int val3 ;
	int ecode3 = 0 ;
	double val4 ;
	int ecode4 = 0 ;
	void *argp5 = 0 ;
	int res5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:weightedLorpeSmooth1D",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "1"" of type '" "npstat::HistoND< unsigned char,npstat::HistoAxis > const &""'");
	}
	arg1 = reinterpret_cast< npstat::HistoND< unsigned char,npstat::HistoAxis > * >(argp1);
	ecode2 = SWIG_AsVal_double(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "weightedLorpeSmooth1D" "', argument " "2"" of type '" "double""'");
	}
	arg2 = static_cast< double >(val2);
	ecode3 = SWIG_AsVal_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "weightedLorpeSmooth1D" "', argument " "3"" of type '" "int""'");
	}
	arg3 = static_cast< int >(val3);
	ecode4 = SWIG_AsVal_double(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "weightedLorpeSmooth1D" "', argument " "4"" of type '" "double""'");
	}
	arg4 = static_cast< double >(val4);
	res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_npstat__BoundaryHandling, 0 \| 0);
	if (!SWIG_IsOK(res5)) {
	SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	if (!argp5) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "weightedLorpeSmooth1D" "', argument " "5"" of type '" "npstat::BoundaryHandling const &""'");
	}
	arg5 = reinterpret_cast< npstat::BoundaryHandling * >(argp5);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR weightedLorpeSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >((npstat::HistoND< unsigned char,npstat::HistoAxis > const &)arg1,arg2,arg3,arg4,(npstat::BoundaryHandling const &)*arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_weightedLorpeSmooth1D(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[7] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 6) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_weightedLorpeSmooth1D__SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_weightedLorpeSmooth1D__SWIG_3(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_weightedLorpeSmooth1D__SWIG_5(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_weightedLorpeSmooth1D__SWIG_7(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_weightedLorpeSmooth1D__SWIG_9(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_long_long_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_weightedLorpeSmooth1D__SWIG_2(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_double_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_weightedLorpeSmooth1D__SWIG_6(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_int_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_weightedLorpeSmooth1D__SWIG_0(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_unsigned_char_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_weightedLorpeSmooth1D__SWIG_8(self, args);
	}
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__HistoNDT_float_npstat__HistoAxis_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_npstat__BoundaryHandling, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_double(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_weightedLorpeSmooth1D__SWIG_4(self, args);
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'weightedLorpeSmooth1D'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::weightedLorpeSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &,double,int,double,npstat::BoundaryHandling const &,double)\n"
	" npstat::weightedLorpeSmooth1DWrap< npstat::HistoND< int,npstat::HistoAxis > >(npstat::HistoND< int,npstat::HistoAxis > const &,double,int,double,npstat::BoundaryHandling const &)\n"
	" npstat::weightedLorpeSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &,double,int,double,npstat::BoundaryHandling const &,double)\n"
	" npstat::weightedLorpeSmooth1DWrap< npstat::HistoND< long long,npstat::HistoAxis > >(npstat::HistoND< long long,npstat::HistoAxis > const &,double,int,double,npstat::BoundaryHandling const &)\n"
	" npstat::weightedLorpeSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &,double,int,double,npstat::BoundaryHandling const &,double)\n"
	" npstat::weightedLorpeSmooth1DWrap< npstat::HistoND< float,npstat::HistoAxis > >(npstat::HistoND< float,npstat::HistoAxis > const &,double,int,double,npstat::BoundaryHandling const &)\n"
	" npstat::weightedLorpeSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &,double,int,double,npstat::BoundaryHandling const &,double)\n"
	" npstat::weightedLorpeSmooth1DWrap< npstat::HistoND< double,npstat::HistoAxis > >(npstat::HistoND< double,npstat::HistoAxis > const &,double,int,double,npstat::BoundaryHandling const &)\n"
	" npstat::weightedLorpeSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &,double,int,double,npstat::BoundaryHandling const &,double)\n"
	" npstat::weightedLorpeSmooth1DWrap< npstat::HistoND< unsigned char,npstat::HistoAxis > >(npstat::HistoND< unsigned char,npstat::HistoAxis > const &,double,int,double,npstat::BoundaryHandling const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_arrayNDToNumpy__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< unsigned char,1U,10U > *arg1 = 0 ;
	bool arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:arrayNDToNumpy",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_unsigned_char_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< unsigned char,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< unsigned char,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< unsigned char,1U,10U > * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayNDToNumpy" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDToNumpy< unsigned char >((npstat::ArrayND< unsigned char,1U,10U > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDToNumpy__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< unsigned char,1U,10U > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:arrayNDToNumpy",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_unsigned_char_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< unsigned char,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< unsigned char,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< unsigned char,1U,10U > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDToNumpy< unsigned char >((npstat::ArrayND< unsigned char,1U,10U > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDToNumpy__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< int,1U,10U > *arg1 = 0 ;
	bool arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:arrayNDToNumpy",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_int_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< int,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< int,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< int,1U,10U > * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayNDToNumpy" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDToNumpy< int >((npstat::ArrayND< int,1U,10U > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDToNumpy__SWIG_5(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< int,1U,10U > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:arrayNDToNumpy",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_int_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< int,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< int,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< int,1U,10U > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDToNumpy< int >((npstat::ArrayND< int,1U,10U > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDToNumpy__SWIG_6(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< long long,1U,10U > *arg1 = 0 ;
	bool arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:arrayNDToNumpy",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_long_long_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< long long,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< long long,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< long long,1U,10U > * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayNDToNumpy" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDToNumpy< long long >((npstat::ArrayND< long long,1U,10U > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDToNumpy__SWIG_7(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< long long,1U,10U > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:arrayNDToNumpy",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_long_long_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< long long,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< long long,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< long long,1U,10U > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDToNumpy< long long >((npstat::ArrayND< long long,1U,10U > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDToNumpy__SWIG_8(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< float,1U,10U > *arg1 = 0 ;
	bool arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:arrayNDToNumpy",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< float,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< float,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< float,1U,10U > * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayNDToNumpy" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDToNumpy< float >((npstat::ArrayND< float,1U,10U > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDToNumpy__SWIG_9(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< float,1U,10U > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:arrayNDToNumpy",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< float,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< float,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< float,1U,10U > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDToNumpy< float >((npstat::ArrayND< float,1U,10U > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDToNumpy__SWIG_10(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< double,1U,10U > *arg1 = 0 ;
	bool arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:arrayNDToNumpy",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< double,1U,10U > * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayNDToNumpy" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDToNumpy< double >((npstat::ArrayND< double,1U,10U > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDToNumpy__SWIG_11(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< double,1U,10U > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:arrayNDToNumpy",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< double,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< double,1U,10U > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDToNumpy< double >((npstat::ArrayND< double,1U,10U > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDToNumpy__SWIG_12(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< std::complex< float >,1U,10U > *arg1 = 0 ;
	bool arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:arrayNDToNumpy",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_std__complexT_float_t_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< std::complex< float >,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< std::complex< float >,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< std::complex< float >,1U,10U > * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayNDToNumpy" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDToNumpy< std::complex< float > >((npstat::ArrayND< std::complex< float >,1U,10U > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDToNumpy__SWIG_13(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< std::complex< float >,1U,10U > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:arrayNDToNumpy",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_std__complexT_float_t_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< std::complex< float >,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< std::complex< float >,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< std::complex< float >,1U,10U > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDToNumpy< std::complex< float > >((npstat::ArrayND< std::complex< float >,1U,10U > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDToNumpy__SWIG_14(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< std::complex< double >,1U,10U > *arg1 = 0 ;
	bool arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:arrayNDToNumpy",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_std__complexT_double_t_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< std::complex< double >,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< std::complex< double >,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< std::complex< double >,1U,10U > * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "arrayNDToNumpy" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDToNumpy< std::complex< double > >((npstat::ArrayND< std::complex< double >,1U,10U > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDToNumpy__SWIG_15(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::ArrayND< std::complex< double >,1U,10U > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:arrayNDToNumpy",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__ArrayNDT_std__complexT_double_t_1U_10U_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< std::complex< double >,1U,10U > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "arrayNDToNumpy" "', argument " "1"" of type '" "npstat::ArrayND< std::complex< double >,1U,10U > const &""'");
	}
	arg1 = reinterpret_cast< npstat::ArrayND< std::complex< double >,1U,10U > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR arrayNDToNumpy< std::complex< double > >((npstat::ArrayND< std::complex< double >,1U,10U > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_arrayNDToNumpy(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_unsigned_char_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_arrayNDToNumpy__SWIG_3(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_int_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_arrayNDToNumpy__SWIG_5(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_long_long_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_arrayNDToNumpy__SWIG_7(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_arrayNDToNumpy__SWIG_9(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_arrayNDToNumpy__SWIG_11(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_std__complexT_float_t_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_arrayNDToNumpy__SWIG_13(self, args);
	}
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_std__complexT_double_t_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_arrayNDToNumpy__SWIG_15(self, args);
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_unsigned_char_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_arrayNDToNumpy__SWIG_2(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_double_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_arrayNDToNumpy__SWIG_10(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_long_long_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_arrayNDToNumpy__SWIG_6(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_std__complexT_float_t_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_arrayNDToNumpy__SWIG_12(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_int_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_arrayNDToNumpy__SWIG_4(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_std__complexT_double_t_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_arrayNDToNumpy__SWIG_14(self, args);
	}
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__ArrayNDT_float_1U_10U_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_arrayNDToNumpy__SWIG_8(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'arrayNDToNumpy'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::arrayNDToNumpy< unsigned char >(npstat::ArrayND< unsigned char,1U,10U > const &,bool)\n"
	" npstat::arrayNDToNumpy< unsigned char >(npstat::ArrayND< unsigned char,1U,10U > const &)\n"
	" npstat::arrayNDToNumpy< int >(npstat::ArrayND< int,1U,10U > const &,bool)\n"
	" npstat::arrayNDToNumpy< int >(npstat::ArrayND< int,1U,10U > const &)\n"
	" npstat::arrayNDToNumpy< long long >(npstat::ArrayND< long long,1U,10U > const &,bool)\n"
	" npstat::arrayNDToNumpy< long long >(npstat::ArrayND< long long,1U,10U > const &)\n"
	" npstat::arrayNDToNumpy< float >(npstat::ArrayND< float,1U,10U > const &,bool)\n"
	" npstat::arrayNDToNumpy< float >(npstat::ArrayND< float,1U,10U > const &)\n"
	" npstat::arrayNDToNumpy< double >(npstat::ArrayND< double,1U,10U > const &,bool)\n"
	" npstat::arrayNDToNumpy< double >(npstat::ArrayND< double,1U,10U > const &)\n"
	" npstat::arrayNDToNumpy< std::complex< float > >(npstat::ArrayND< std::complex< float >,1U,10U > const &,bool)\n"
	" npstat::arrayNDToNumpy< std::complex< float > >(npstat::ArrayND< std::complex< float >,1U,10U > const &)\n"
	" npstat::arrayNDToNumpy< std::complex< double > >(npstat::ArrayND< std::complex< double >,1U,10U > const &,bool)\n"
	" npstat::arrayNDToNumpy< std::complex< double > >(npstat::ArrayND< std::complex< double >,1U,10U > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_matrixToNumpy__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Matrix< double,16 > *arg1 = 0 ;
	bool arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	bool val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:matrixToNumpy",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__MatrixT_double_16_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "matrixToNumpy" "', argument " "1"" of type '" "npstat::Matrix< double,16 > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "matrixToNumpy" "', argument " "1"" of type '" "npstat::Matrix< double,16 > const &""'");
	}
	arg1 = reinterpret_cast< npstat::Matrix< double,16 > * >(argp1);
	ecode2 = SWIG_AsVal_bool(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "matrixToNumpy" "', argument " "2"" of type '" "bool""'");
	}
	arg2 = static_cast< bool >(val2);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR matrixToNumpy< double >((npstat::Matrix< double,16 > const &)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_matrixToNumpy__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	npstat::Matrix< double,16 > *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:matrixToNumpy",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_npstat__MatrixT_double_16_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "matrixToNumpy" "', argument " "1"" of type '" "npstat::Matrix< double,16 > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "matrixToNumpy" "', argument " "1"" of type '" "npstat::Matrix< double,16 > const &""'");
	}
	arg1 = reinterpret_cast< npstat::Matrix< double,16 > * >(argp1);
	{
	try {
	result = (PyObject )npstat::SWIGTEMPLATEDISAMBIGUATOR matrixToNumpy< double >((npstat::Matrix< double,16 > const &)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_matrixToNumpy(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__MatrixT_double_16_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_matrixToNumpy__SWIG_3(self, args);
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_npstat__MatrixT_double_16_t, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_bool(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_matrixToNumpy__SWIG_2(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'matrixToNumpy'.\n"
	" Possible C/C++ prototypes are:\n"
	" npstat::matrixToNumpy< double >(npstat::Matrix< double,16 > const &,bool)\n"
	" npstat::matrixToNumpy< double >(npstat::Matrix< double,16 > const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_BinaryArchiveBase(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryArchiveBase arg1 = (gs::BinaryArchiveBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_BinaryArchiveBase",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryArchiveBase, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinaryArchiveBase" "', argument " "1"" of type '" "gs::BinaryArchiveBase *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryArchiveBase * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryArchiveBase_isOpen(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryArchiveBase arg1 = (gs::BinaryArchiveBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:BinaryArchiveBase_isOpen",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryArchiveBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryArchiveBase_isOpen" "', argument " "1"" of type '" "gs::BinaryArchiveBase const *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryArchiveBase * >(argp1);
	{
	try {
	result = (bool)((gs::BinaryArchiveBase const *)arg1)->isOpen();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryArchiveBase_isReadable(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryArchiveBase arg1 = (gs::BinaryArchiveBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:BinaryArchiveBase_isReadable",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryArchiveBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryArchiveBase_isReadable" "', argument " "1"" of type '" "gs::BinaryArchiveBase const *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryArchiveBase * >(argp1);
	{
	try {
	result = (bool)((gs::BinaryArchiveBase const *)arg1)->isReadable();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryArchiveBase_isWritable(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryArchiveBase arg1 = (gs::BinaryArchiveBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:BinaryArchiveBase_isWritable",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryArchiveBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryArchiveBase_isWritable" "', argument " "1"" of type '" "gs::BinaryArchiveBase const *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryArchiveBase * >(argp1);
	{
	try {
	result = (bool)((gs::BinaryArchiveBase const *)arg1)->isWritable();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryArchiveBase_error(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryArchiveBase arg1 = (gs::BinaryArchiveBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::string result;

	if (!PyArg_ParseTuple(args,(char *)"O:BinaryArchiveBase_error",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryArchiveBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryArchiveBase_error" "', argument " "1"" of type '" "gs::BinaryArchiveBase const *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryArchiveBase * >(argp1);
	{
	try {
	result = ((gs::BinaryArchiveBase const *)arg1)->error();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryArchiveBase_modeValid(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryArchiveBase arg1 = (gs::BinaryArchiveBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:BinaryArchiveBase_modeValid",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryArchiveBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryArchiveBase_modeValid" "', argument " "1"" of type '" "gs::BinaryArchiveBase const *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryArchiveBase * >(argp1);
	{
	try {
	result = (bool)((gs::BinaryArchiveBase const *)arg1)->modeValid();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryArchiveBase_size(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryArchiveBase arg1 = (gs::BinaryArchiveBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long long result;

	if (!PyArg_ParseTuple(args,(char *)"O:BinaryArchiveBase_size",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryArchiveBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryArchiveBase_size" "', argument " "1"" of type '" "gs::BinaryArchiveBase const *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryArchiveBase * >(argp1);
	{
	try {
	result = (unsigned long long)((gs::BinaryArchiveBase const *)arg1)->size();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryArchiveBase_smallestId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryArchiveBase arg1 = (gs::BinaryArchiveBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long long result;

	if (!PyArg_ParseTuple(args,(char *)"O:BinaryArchiveBase_smallestId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryArchiveBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryArchiveBase_smallestId" "', argument " "1"" of type '" "gs::BinaryArchiveBase const *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryArchiveBase * >(argp1);
	{
	try {
	result = (unsigned long long)((gs::BinaryArchiveBase const *)arg1)->smallestId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryArchiveBase_largestId(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryArchiveBase arg1 = (gs::BinaryArchiveBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned long long result;

	if (!PyArg_ParseTuple(args,(char *)"O:BinaryArchiveBase_largestId",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryArchiveBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryArchiveBase_largestId" "', argument " "1"" of type '" "gs::BinaryArchiveBase const *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryArchiveBase * >(argp1);
	{
	try {
	result = (unsigned long long)((gs::BinaryArchiveBase const *)arg1)->largestId();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryArchiveBase_idsAreContiguous(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryArchiveBase arg1 = (gs::BinaryArchiveBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:BinaryArchiveBase_idsAreContiguous",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryArchiveBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryArchiveBase_idsAreContiguous" "', argument " "1"" of type '" "gs::BinaryArchiveBase const *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryArchiveBase * >(argp1);
	{
	try {
	result = (bool)((gs::BinaryArchiveBase const *)arg1)->idsAreContiguous();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryArchiveBase_itemExists(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryArchiveBase arg1 = (gs::BinaryArchiveBase ) 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:BinaryArchiveBase_itemExists",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryArchiveBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryArchiveBase_itemExists" "', argument " "1"" of type '" "gs::BinaryArchiveBase const *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryArchiveBase * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BinaryArchiveBase_itemExists" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (bool)((gs::BinaryArchiveBase const *)arg1)->itemExists(arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryArchiveBase_itemSearch(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryArchiveBase arg1 = (gs::BinaryArchiveBase ) 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	std::vector< unsigned long long,std::allocator< unsigned long long > > arg4 = (std::vector< unsigned long long,std::allocator< unsigned long long > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	void *argp4 = 0 ;
	int res4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:BinaryArchiveBase_itemSearch",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryArchiveBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryArchiveBase_itemSearch" "', argument " "1"" of type '" "gs::BinaryArchiveBase const *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryArchiveBase * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BinaryArchiveBase_itemSearch" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BinaryArchiveBase_itemSearch" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BinaryArchiveBase_itemSearch" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BinaryArchiveBase_itemSearch" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_std__vectorT_unsigned_long_long_std__allocatorT_unsigned_long_long_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res4)) {
	SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BinaryArchiveBase_itemSearch" "', argument " "4"" of type '" "std::vector< unsigned long long,std::allocator< unsigned long long > > *""'");
	}
	arg4 = reinterpret_cast< std::vector< unsigned long long,std::allocator< unsigned long long > > * >(argp4);
	{
	try {
	((gs::BinaryArchiveBase const )arg1)->itemSearch((gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)*arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryArchiveBase_compressionBufferSize(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryArchiveBase arg1 = (gs::BinaryArchiveBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	std::size_t result;

	if (!PyArg_ParseTuple(args,(char *)"O:BinaryArchiveBase_compressionBufferSize",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryArchiveBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryArchiveBase_compressionBufferSize" "', argument " "1"" of type '" "gs::BinaryArchiveBase const *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryArchiveBase * >(argp1);
	{
	try {
	result = ((gs::BinaryArchiveBase const *)arg1)->compressionBufferSize();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_size_t(static_cast< size_t >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryArchiveBase_compressionLevel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryArchiveBase arg1 = (gs::BinaryArchiveBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	int result;

	if (!PyArg_ParseTuple(args,(char *)"O:BinaryArchiveBase_compressionLevel",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryArchiveBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryArchiveBase_compressionLevel" "', argument " "1"" of type '" "gs::BinaryArchiveBase const *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryArchiveBase * >(argp1);
	{
	try {
	result = (int)((gs::BinaryArchiveBase const *)arg1)->compressionLevel();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_int(static_cast< int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryArchiveBase_minSizeToCompress(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryArchiveBase arg1 = (gs::BinaryArchiveBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"O:BinaryArchiveBase_minSizeToCompress",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryArchiveBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryArchiveBase_minSizeToCompress" "', argument " "1"" of type '" "gs::BinaryArchiveBase const *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryArchiveBase * >(argp1);
	{
	try {
	result = (unsigned int)((gs::BinaryArchiveBase const *)arg1)->minSizeToCompress();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryArchiveBase_injectMetadata(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryArchiveBase arg1 = (gs::BinaryArchiveBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:BinaryArchiveBase_injectMetadata",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryArchiveBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryArchiveBase_injectMetadata" "', argument " "1"" of type '" "gs::BinaryArchiveBase const *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryArchiveBase * >(argp1);
	{
	try {
	result = (bool)((gs::BinaryArchiveBase const *)arg1)->injectMetadata();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryArchiveBase_isEmptyFile(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::fstream *arg1 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"O:BinaryArchiveBase_isEmptyFile",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__fstream, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryArchiveBase_isEmptyFile" "', argument " "1"" of type '" "std::fstream &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BinaryArchiveBase_isEmptyFile" "', argument " "1"" of type '" "std::fstream &""'");
	}
	arg1 = reinterpret_cast< std::fstream * >(argp1);
	{
	try {
	result = (bool)gs::BinaryArchiveBase::isEmptyFile(*arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryArchiveBase_compression(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryArchiveBase arg1 = (gs::BinaryArchiveBase ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;
	int result;

	if (!PyArg_ParseTuple(args,(char *)"O:BinaryArchiveBase_compression",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryArchiveBase, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryArchiveBase_compression" "', argument " "1"" of type '" "gs::BinaryArchiveBase const *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryArchiveBase * >(argp1);
	{
	try {
	result = (int)gs_BinaryArchiveBase_compression((gs::BinaryArchiveBase const *)arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_int(static_cast< int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject BinaryArchiveBase_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__BinaryArchiveBase, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_writeStringArchive(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:writeStringArchive",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__StringArchive, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "writeStringArchive" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "writeStringArchive" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "writeStringArchive" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	{
	try {
	result = (bool)gs::writeStringArchive((gs::StringArchive const &)arg1,(char const )arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_readStringArchive(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char arg1 = (char ) 0 ;
	int res1 ;
	char *buf1 = 0 ;
	int alloc1 = 0 ;
	PyObject * obj0 = 0 ;
	gs::StringArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:readStringArchive",&obj0)) SWIG_fail;
	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "readStringArchive" "', argument " "1"" of type '" "char const *""'");
	}
	arg1 = reinterpret_cast< char * >(buf1);
	{
	try {
	result = (gs::StringArchive )gs::readStringArchive((char const )arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__StringArchive, SWIG_POINTER_OWN \| 0 );
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	return resultobj;
	fail:
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_writeCompressedStringArchive__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	unsigned int arg3 ;
	int arg4 ;
	unsigned int arg5 ;
	unsigned int arg6 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:writeCompressedStringArchive",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__StringArchive, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "writeCompressedStringArchive" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "writeCompressedStringArchive" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "writeCompressedStringArchive" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "writeCompressedStringArchive" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "writeCompressedStringArchive" "', argument " "4"" of type '" "int""'");
	}
	arg4 = static_cast< int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "writeCompressedStringArchive" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "writeCompressedStringArchive" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	{
	try {
	result = (bool)gs::writeCompressedStringArchive((gs::StringArchive const &)arg1,(char const )arg2,arg3,arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_writeCompressedStringArchive__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	unsigned int arg3 ;
	int arg4 ;
	unsigned int arg5 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:writeCompressedStringArchive",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__StringArchive, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "writeCompressedStringArchive" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "writeCompressedStringArchive" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "writeCompressedStringArchive" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "writeCompressedStringArchive" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "writeCompressedStringArchive" "', argument " "4"" of type '" "int""'");
	}
	arg4 = static_cast< int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "writeCompressedStringArchive" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	result = (bool)gs::writeCompressedStringArchive((gs::StringArchive const &)arg1,(char const )arg2,arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_writeCompressedStringArchive__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	unsigned int arg3 ;
	int arg4 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:writeCompressedStringArchive",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__StringArchive, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "writeCompressedStringArchive" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "writeCompressedStringArchive" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "writeCompressedStringArchive" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "writeCompressedStringArchive" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	ecode4 = SWIG_AsVal_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "writeCompressedStringArchive" "', argument " "4"" of type '" "int""'");
	}
	arg4 = static_cast< int >(val4);
	{
	try {
	result = (bool)gs::writeCompressedStringArchive((gs::StringArchive const &)arg1,(char const )arg2,arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_writeCompressedStringArchive__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	unsigned int arg3 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	unsigned int val3 ;
	int ecode3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:writeCompressedStringArchive",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__StringArchive, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "writeCompressedStringArchive" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "writeCompressedStringArchive" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "writeCompressedStringArchive" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	if (!SWIG_IsOK(ecode3)) {
	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "writeCompressedStringArchive" "', argument " "3"" of type '" "unsigned int""'");
	}
	arg3 = static_cast< unsigned int >(val3);
	{
	try {
	result = (bool)gs::writeCompressedStringArchive((gs::StringArchive const &)arg1,(char const )arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_writeCompressedStringArchive__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:writeCompressedStringArchive",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__StringArchive, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "writeCompressedStringArchive" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "writeCompressedStringArchive" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "writeCompressedStringArchive" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	{
	try {
	result = (bool)gs::writeCompressedStringArchive((gs::StringArchive const &)arg1,(char const )arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_writeCompressedStringArchive(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[7] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 6) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gs__StringArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_writeCompressedStringArchive__SWIG_4(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gs__StringArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_writeCompressedStringArchive__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gs__StringArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_writeCompressedStringArchive__SWIG_2(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gs__StringArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_writeCompressedStringArchive__SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gs__StringArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_writeCompressedStringArchive__SWIG_0(self, args);
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'writeCompressedStringArchive'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::writeCompressedStringArchive(gs::StringArchive const &,char const *,unsigned int,int,unsigned int,unsigned int)\n"
	" gs::writeCompressedStringArchive(gs::StringArchive const &,char const *,unsigned int,int,unsigned int)\n"
	" gs::writeCompressedStringArchive(gs::StringArchive const &,char const *,unsigned int,int)\n"
	" gs::writeCompressedStringArchive(gs::StringArchive const &,char const *,unsigned int)\n"
	" gs::writeCompressedStringArchive(gs::StringArchive const &,char const *)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_readCompressedStringArchive(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char arg1 = (char ) 0 ;
	int res1 ;
	char *buf1 = 0 ;
	int alloc1 = 0 ;
	PyObject * obj0 = 0 ;
	gs::StringArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:readCompressedStringArchive",&obj0)) SWIG_fail;
	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "readCompressedStringArchive" "', argument " "1"" of type '" "char const *""'");
	}
	arg1 = reinterpret_cast< char * >(buf1);
	{
	try {
	result = (gs::StringArchive )gs::readCompressedStringArchive((char const )arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__StringArchive, SWIG_POINTER_OWN \| 0 );
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	return resultobj;
	fail:
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_writeCompressedStringArchiveExt__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:writeCompressedStringArchiveExt",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__StringArchive, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "writeCompressedStringArchiveExt" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "writeCompressedStringArchiveExt" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "writeCompressedStringArchiveExt" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "writeCompressedStringArchiveExt" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (bool)gs::writeCompressedStringArchiveExt((gs::StringArchive const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_writeCompressedStringArchiveExt__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::StringArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:writeCompressedStringArchiveExt",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__StringArchive, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "writeCompressedStringArchiveExt" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "writeCompressedStringArchiveExt" "', argument " "1"" of type '" "gs::StringArchive const &""'");
	}
	arg1 = reinterpret_cast< gs::StringArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "writeCompressedStringArchiveExt" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	{
	try {
	result = (bool)gs::writeCompressedStringArchiveExt((gs::StringArchive const &)arg1,(char const )arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_writeCompressedStringArchiveExt(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gs__StringArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_writeCompressedStringArchiveExt__SWIG_1(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_gs__StringArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_writeCompressedStringArchiveExt__SWIG_0(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'writeCompressedStringArchiveExt'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::writeCompressedStringArchiveExt(gs::StringArchive const &,char const ,char const )\n"
	" gs::writeCompressedStringArchiveExt(gs::StringArchive const &,char const *)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_readCompressedStringArchiveExt__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char arg1 = (char ) 0 ;
	char arg2 = (char ) 0 ;
	int res1 ;
	char *buf1 = 0 ;
	int alloc1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::StringArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:readCompressedStringArchiveExt",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "readCompressedStringArchiveExt" "', argument " "1"" of type '" "char const *""'");
	}
	arg1 = reinterpret_cast< char * >(buf1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "readCompressedStringArchiveExt" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	{
	try {
	result = (gs::StringArchive )gs::readCompressedStringArchiveExt((char const )arg1,(char const *)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__StringArchive, SWIG_POINTER_OWN \| 0 );
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return resultobj;
	fail:
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_readCompressedStringArchiveExt__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char arg1 = (char ) 0 ;
	int res1 ;
	char *buf1 = 0 ;
	int alloc1 = 0 ;
	PyObject * obj0 = 0 ;
	gs::StringArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:readCompressedStringArchiveExt",&obj0)) SWIG_fail;
	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "readCompressedStringArchiveExt" "', argument " "1"" of type '" "char const *""'");
	}
	arg1 = reinterpret_cast< char * >(buf1);
	{
	try {
	result = (gs::StringArchive )gs::readCompressedStringArchiveExt((char const )arg1);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__StringArchive, SWIG_POINTER_OWN \| 0 );
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	return resultobj;
	fail:
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_readCompressedStringArchiveExt(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[3] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 2) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 1) {
	int _v;
	int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_readCompressedStringArchiveExt__SWIG_1(self, args);
	}
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_readCompressedStringArchiveExt__SWIG_0(self, args);
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'readCompressedStringArchiveExt'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::readCompressedStringArchiveExt(char const ,char const )\n"
	" gs::readCompressedStringArchiveExt(char const *)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_loadStringArchiveFromArchive(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::StringArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:loadStringArchiveFromArchive",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "loadStringArchiveFromArchive" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "loadStringArchiveFromArchive" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "loadStringArchiveFromArchive" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::StringArchive )gs::loadStringArchiveFromArchive(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__StringArchive, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_Bool(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	bool *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	bool temp1 ;
	bool val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< bool > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_Bool",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_bool(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArchiveValueRecord_Bool" "', argument " "1"" of type '" "bool""'");
	}
	temp1 = static_cast< bool >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_Bool" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_Bool" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< bool > )new gs::ArchiveValueRecord< bool >((bool const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_bool_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_Bool(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< bool > arg1 = (gs::ArchiveValueRecord< bool > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_Bool",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_bool_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_Bool" "', argument " "1"" of type '" "gs::ArchiveValueRecord< bool > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< bool > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_Bool_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_bool_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_Bool(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	bool *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	bool temp1 ;
	bool val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< bool > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_Bool",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_bool(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NPValueRecord_Bool" "', argument " "1"" of type '" "bool""'");
	}
	temp1 = static_cast< bool >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_Bool" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_Bool" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< bool >((bool const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< bool >(static_cast< const gs::ArchiveValueRecord< bool >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_bool_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Bool__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< bool > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_Bool",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Bool" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Bool" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_Bool" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< bool > )new gs::Reference< bool >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_bool_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Bool__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< bool > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_Bool",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Bool" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Bool" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_Bool" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_Bool" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< bool > )new gs::Reference< bool >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_bool_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Bool__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< bool > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_Bool",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Bool" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Bool" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_Bool" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Bool" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_Bool" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Bool" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< bool > )new gs::Reference< bool >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_bool_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Bool(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_Bool__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_Bool__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_Bool__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_Bool'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< bool >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< bool >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< bool >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_Bool_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< bool > arg1 = (gs::Reference< bool > ) 0 ;
	unsigned long arg2 ;
	bool arg3 = (bool ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_Bool_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_bool_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Bool_restore" "', argument " "1"" of type '" "gs::Reference< bool > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< bool > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Bool_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_bool, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_Bool_restore" "', argument " "3"" of type '" "bool *""'");
	}
	arg3 = reinterpret_cast< bool * >(argp3);
	{
	try {
	((gs::Reference< bool > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_Bool_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< bool > arg1 = (gs::Reference< bool > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_Bool_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_bool_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Bool_retrieve" "', argument " "1"" of type '" "gs::Reference< bool > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< bool > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Bool_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (bool )gs_Reference_Sl_bool_Sg__retrieve((gs::Reference< bool > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bool, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_Bool_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< bool > arg1 = (gs::Reference< bool > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	bool result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_Bool_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_bool_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Bool_getValue" "', argument " "1"" of type '" "gs::Reference< bool > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< bool > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Bool_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (bool)gs_Reference_Sl_bool_Sg__getValue((gs::Reference< bool > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_bool(static_cast< bool >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_Bool(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< bool > arg1 = (gs::Reference< bool > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_Bool",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_bool_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_Bool" "', argument " "1"" of type '" "gs::Reference< bool > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< bool > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_Bool_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_bool_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_Char(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	char temp1 ;
	char val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_Char",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_char(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArchiveValueRecord_Char" "', argument " "1"" of type '" "char""'");
	}
	temp1 = static_cast< char >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_Char" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_Char" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< char > )new gs::ArchiveValueRecord< char >((char const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_char_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_Char(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< char > arg1 = (gs::ArchiveValueRecord< char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_Char",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_char_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_Char" "', argument " "1"" of type '" "gs::ArchiveValueRecord< char > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< char > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_Char_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_char_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_Char(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	char temp1 ;
	char val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< char > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_Char",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_char(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NPValueRecord_Char" "', argument " "1"" of type '" "char""'");
	}
	temp1 = static_cast< char >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_Char" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_Char" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< char >((char const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< char >(static_cast< const gs::ArchiveValueRecord< char >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_char_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Char__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_Char",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Char" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Char" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_Char" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< char > )new gs::Reference< char >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_char_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Char__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_Char",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Char" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Char" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_Char" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_Char" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< char > )new gs::Reference< char >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_char_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Char__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_Char",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Char" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Char" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_Char" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Char" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_Char" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Char" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< char > )new gs::Reference< char >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_char_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Char(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_Char__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_Char__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_Char__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_Char'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< char >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< char >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< char >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_Char_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< char > arg1 = (gs::Reference< char > ) 0 ;
	unsigned long arg2 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_Char_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Char_restore" "', argument " "1"" of type '" "gs::Reference< char > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< char > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Char_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_Char_restore" "', argument " "3"" of type '" "char *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	((gs::Reference< char > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_Char_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< char > arg1 = (gs::Reference< char > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_Char_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Char_retrieve" "', argument " "1"" of type '" "gs::Reference< char > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< char > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Char_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (char )gs_Reference_Sl_char_Sg__retrieve((gs::Reference< char > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_FromCharPtr((const char *)result);
	delete[] result;
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_Char_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< char > arg1 = (gs::Reference< char > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	char result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_Char_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Char_getValue" "', argument " "1"" of type '" "gs::Reference< char > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< char > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Char_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (char)gs_Reference_Sl_char_Sg__getValue((gs::Reference< char > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_char(static_cast< char >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_Char(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< char > arg1 = (gs::Reference< char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_Char",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_char_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_Char" "', argument " "1"" of type '" "gs::Reference< char > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< char > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_Char_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_char_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_UChar(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned char *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	unsigned char temp1 ;
	unsigned char val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< unsigned char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_UChar",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArchiveValueRecord_UChar" "', argument " "1"" of type '" "unsigned char""'");
	}
	temp1 = static_cast< unsigned char >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_UChar" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_UChar" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< unsigned char > )new gs::ArchiveValueRecord< unsigned char >((unsigned char const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_char_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_UChar(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< unsigned char > arg1 = (gs::ArchiveValueRecord< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_UChar",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_char_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_UChar" "', argument " "1"" of type '" "gs::ArchiveValueRecord< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< unsigned char > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_UChar_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_char_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_UChar(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned char *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	unsigned char temp1 ;
	unsigned char val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< unsigned char > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_UChar",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NPValueRecord_UChar" "', argument " "1"" of type '" "unsigned char""'");
	}
	temp1 = static_cast< unsigned char >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_UChar" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_UChar" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< unsigned char >((unsigned char const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< unsigned char >(static_cast< const gs::ArchiveValueRecord< unsigned char >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_char_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UChar__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< unsigned char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_UChar",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UChar" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UChar" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_UChar" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< unsigned char > )new gs::Reference< unsigned char >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_unsigned_char_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UChar__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< unsigned char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_UChar",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UChar" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UChar" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_UChar" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_UChar" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< unsigned char > )new gs::Reference< unsigned char >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_unsigned_char_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UChar__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< unsigned char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_UChar",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UChar" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UChar" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_UChar" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UChar" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_UChar" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UChar" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< unsigned char > )new gs::Reference< unsigned char >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_unsigned_char_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UChar(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_UChar__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_UChar__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_UChar__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_UChar'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< unsigned char >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< unsigned char >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< unsigned char >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_UChar_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned char > arg1 = (gs::Reference< unsigned char > ) 0 ;
	unsigned long arg2 ;
	unsigned char arg3 = (unsigned char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_UChar_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UChar_restore" "', argument " "1"" of type '" "gs::Reference< unsigned char > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned char > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UChar_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_char, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_UChar_restore" "', argument " "3"" of type '" "unsigned char *""'");
	}
	arg3 = reinterpret_cast< unsigned char * >(argp3);
	{
	try {
	((gs::Reference< unsigned char > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_UChar_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned char > arg1 = (gs::Reference< unsigned char > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	unsigned char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_UChar_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UChar_retrieve" "', argument " "1"" of type '" "gs::Reference< unsigned char > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned char > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UChar_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (unsigned char )gs_Reference_Sl_unsigned_SS_char_Sg__retrieve((gs::Reference< unsigned char > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_UChar_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned char > arg1 = (gs::Reference< unsigned char > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	unsigned char result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_UChar_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UChar_getValue" "', argument " "1"" of type '" "gs::Reference< unsigned char > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned char > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UChar_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (unsigned char)gs_Reference_Sl_unsigned_SS_char_Sg__getValue((gs::Reference< unsigned char > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_UChar(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned char > arg1 = (gs::Reference< unsigned char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_UChar",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_char_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_UChar" "', argument " "1"" of type '" "gs::Reference< unsigned char > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned char > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_UChar_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_unsigned_char_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_SChar(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	signed char *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	signed char temp1 ;
	signed char val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< signed char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_SChar",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_signed_SS_char(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArchiveValueRecord_SChar" "', argument " "1"" of type '" "signed char""'");
	}
	temp1 = static_cast< signed char >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_SChar" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_SChar" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< signed char > )new gs::ArchiveValueRecord< signed char >((signed char const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_signed_char_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_SChar(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< signed char > arg1 = (gs::ArchiveValueRecord< signed char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_SChar",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_signed_char_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_SChar" "', argument " "1"" of type '" "gs::ArchiveValueRecord< signed char > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< signed char > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_SChar_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_signed_char_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_SChar(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	signed char *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	signed char temp1 ;
	signed char val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< signed char > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_SChar",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_signed_SS_char(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NPValueRecord_SChar" "', argument " "1"" of type '" "signed char""'");
	}
	temp1 = static_cast< signed char >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_SChar" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_SChar" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< signed char >((signed char const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< signed char >(static_cast< const gs::ArchiveValueRecord< signed char >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_signed_char_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_SChar__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< signed char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_SChar",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_SChar" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_SChar" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_SChar" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< signed char > )new gs::Reference< signed char >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_signed_char_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_SChar__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< signed char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_SChar",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_SChar" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_SChar" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_SChar" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_SChar" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< signed char > )new gs::Reference< signed char >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_signed_char_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_SChar__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< signed char > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_SChar",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_SChar" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_SChar" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_SChar" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_SChar" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_SChar" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_SChar" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< signed char > )new gs::Reference< signed char >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_signed_char_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_SChar(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_SChar__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_SChar__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_SChar__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_SChar'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< signed char >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< signed char >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< signed char >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_SChar_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< signed char > arg1 = (gs::Reference< signed char > ) 0 ;
	unsigned long arg2 ;
	signed char arg3 = (signed char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_SChar_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_signed_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_SChar_restore" "', argument " "1"" of type '" "gs::Reference< signed char > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< signed char > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_SChar_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_signed_char, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_SChar_restore" "', argument " "3"" of type '" "signed char *""'");
	}
	arg3 = reinterpret_cast< signed char * >(argp3);
	{
	try {
	((gs::Reference< signed char > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_SChar_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< signed char > arg1 = (gs::Reference< signed char > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	signed char *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_SChar_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_signed_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_SChar_retrieve" "', argument " "1"" of type '" "gs::Reference< signed char > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< signed char > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_SChar_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (signed char )gs_Reference_Sl_signed_SS_char_Sg__retrieve((gs::Reference< signed char > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_signed_char, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_SChar_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< signed char > arg1 = (gs::Reference< signed char > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	signed char result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_SChar_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_signed_char_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_SChar_getValue" "', argument " "1"" of type '" "gs::Reference< signed char > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< signed char > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_SChar_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (signed char)gs_Reference_Sl_signed_SS_char_Sg__getValue((gs::Reference< signed char > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_signed_SS_char(static_cast< signed char >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_SChar(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< signed char > arg1 = (gs::Reference< signed char > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_SChar",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_signed_char_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_SChar" "', argument " "1"" of type '" "gs::Reference< signed char > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< signed char > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_SChar_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_signed_char_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_Short(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	short *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	short temp1 ;
	short val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< short > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_Short",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_short(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArchiveValueRecord_Short" "', argument " "1"" of type '" "short""'");
	}
	temp1 = static_cast< short >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_Short" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_Short" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< short > )new gs::ArchiveValueRecord< short >((short const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_short_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_Short(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< short > arg1 = (gs::ArchiveValueRecord< short > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_Short",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_short_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_Short" "', argument " "1"" of type '" "gs::ArchiveValueRecord< short > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< short > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_Short_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_short_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_Short(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	short *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	short temp1 ;
	short val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< short > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_Short",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_short(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NPValueRecord_Short" "', argument " "1"" of type '" "short""'");
	}
	temp1 = static_cast< short >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_Short" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_Short" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< short >((short const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< short >(static_cast< const gs::ArchiveValueRecord< short >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_short_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Short__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< short > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_Short",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Short" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Short" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_Short" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< short > )new gs::Reference< short >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_short_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Short__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< short > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_Short",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Short" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Short" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_Short" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_Short" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< short > )new gs::Reference< short >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_short_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Short__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< short > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_Short",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Short" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Short" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_Short" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Short" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_Short" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Short" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< short > )new gs::Reference< short >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_short_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Short(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_Short__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_Short__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_Short__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_Short'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< short >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< short >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< short >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_Short_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< short > arg1 = (gs::Reference< short > ) 0 ;
	unsigned long arg2 ;
	short arg3 = (short ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_Short_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_short_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Short_restore" "', argument " "1"" of type '" "gs::Reference< short > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< short > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Short_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_short, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_Short_restore" "', argument " "3"" of type '" "short *""'");
	}
	arg3 = reinterpret_cast< short * >(argp3);
	{
	try {
	((gs::Reference< short > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_Short_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< short > arg1 = (gs::Reference< short > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	short *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_Short_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_short_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Short_retrieve" "', argument " "1"" of type '" "gs::Reference< short > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< short > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Short_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (short )gs_Reference_Sl_short_Sg__retrieve((gs::Reference< short > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_Short_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< short > arg1 = (gs::Reference< short > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	short result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_Short_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_short_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Short_getValue" "', argument " "1"" of type '" "gs::Reference< short > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< short > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Short_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (short)gs_Reference_Sl_short_Sg__getValue((gs::Reference< short > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_short(static_cast< short >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_Short(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< short > arg1 = (gs::Reference< short > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_Short",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_short_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_Short" "', argument " "1"" of type '" "gs::Reference< short > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< short > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_Short_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_short_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_UShort(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned short *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	unsigned short temp1 ;
	unsigned short val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< unsigned short > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_UShort",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_short(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArchiveValueRecord_UShort" "', argument " "1"" of type '" "unsigned short""'");
	}
	temp1 = static_cast< unsigned short >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_UShort" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_UShort" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< unsigned short > )new gs::ArchiveValueRecord< unsigned short >((unsigned short const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_short_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_UShort(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< unsigned short > arg1 = (gs::ArchiveValueRecord< unsigned short > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_UShort",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_short_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_UShort" "', argument " "1"" of type '" "gs::ArchiveValueRecord< unsigned short > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< unsigned short > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_UShort_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_short_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_UShort(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned short *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	unsigned short temp1 ;
	unsigned short val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< unsigned short > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_UShort",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_short(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NPValueRecord_UShort" "', argument " "1"" of type '" "unsigned short""'");
	}
	temp1 = static_cast< unsigned short >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_UShort" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_UShort" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< unsigned short >((unsigned short const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< unsigned short >(static_cast< const gs::ArchiveValueRecord< unsigned short >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_short_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UShort__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< unsigned short > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_UShort",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UShort" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UShort" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_UShort" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< unsigned short > )new gs::Reference< unsigned short >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_unsigned_short_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UShort__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< unsigned short > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_UShort",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UShort" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UShort" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_UShort" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_UShort" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< unsigned short > )new gs::Reference< unsigned short >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_unsigned_short_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UShort__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< unsigned short > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_UShort",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UShort" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UShort" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_UShort" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UShort" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_UShort" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UShort" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< unsigned short > )new gs::Reference< unsigned short >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_unsigned_short_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UShort(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_UShort__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_UShort__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_UShort__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_UShort'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< unsigned short >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< unsigned short >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< unsigned short >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_UShort_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned short > arg1 = (gs::Reference< unsigned short > ) 0 ;
	unsigned long arg2 ;
	unsigned short arg3 = (unsigned short ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_UShort_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_short_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UShort_restore" "', argument " "1"" of type '" "gs::Reference< unsigned short > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned short > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UShort_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_short, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_UShort_restore" "', argument " "3"" of type '" "unsigned short *""'");
	}
	arg3 = reinterpret_cast< unsigned short * >(argp3);
	{
	try {
	((gs::Reference< unsigned short > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_UShort_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned short > arg1 = (gs::Reference< unsigned short > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	unsigned short *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_UShort_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_short_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UShort_retrieve" "', argument " "1"" of type '" "gs::Reference< unsigned short > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned short > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UShort_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (unsigned short )gs_Reference_Sl_unsigned_SS_short_Sg__retrieve((gs::Reference< unsigned short > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_UShort_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned short > arg1 = (gs::Reference< unsigned short > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	unsigned short result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_UShort_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_short_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UShort_getValue" "', argument " "1"" of type '" "gs::Reference< unsigned short > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned short > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UShort_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (unsigned short)gs_Reference_Sl_unsigned_SS_short_Sg__getValue((gs::Reference< unsigned short > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_UShort(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned short > arg1 = (gs::Reference< unsigned short > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_UShort",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_short_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_UShort" "', argument " "1"" of type '" "gs::Reference< unsigned short > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned short > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_UShort_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_unsigned_short_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_Int(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int temp1 ;
	int val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< int > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_Int",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArchiveValueRecord_Int" "', argument " "1"" of type '" "int""'");
	}
	temp1 = static_cast< int >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_Int" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_Int" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< int > )new gs::ArchiveValueRecord< int >((int const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_int_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_Int(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< int > arg1 = (gs::ArchiveValueRecord< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_Int",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_int_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_Int" "', argument " "1"" of type '" "gs::ArchiveValueRecord< int > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< int > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_Int_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_int_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_Int(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	int *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int temp1 ;
	int val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< int > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_Int",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NPValueRecord_Int" "', argument " "1"" of type '" "int""'");
	}
	temp1 = static_cast< int >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_Int" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_Int" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< int >((int const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< int >(static_cast< const gs::ArchiveValueRecord< int >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_int_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Int__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< int > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_Int",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Int" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Int" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_Int" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< int > )new gs::Reference< int >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_int_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Int__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< int > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_Int",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Int" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Int" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_Int" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_Int" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< int > )new gs::Reference< int >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_int_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Int__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< int > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_Int",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Int" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Int" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_Int" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Int" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_Int" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Int" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< int > )new gs::Reference< int >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_int_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Int(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_Int__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_Int__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_Int__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_Int'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< int >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< int >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< int >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_Int_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< int > arg1 = (gs::Reference< int > ) 0 ;
	unsigned long arg2 ;
	int arg3 = (int ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_Int_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Int_restore" "', argument " "1"" of type '" "gs::Reference< int > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< int > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Int_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_Int_restore" "', argument " "3"" of type '" "int *""'");
	}
	arg3 = reinterpret_cast< int * >(argp3);
	{
	try {
	((gs::Reference< int > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_Int_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< int > arg1 = (gs::Reference< int > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	int *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_Int_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Int_retrieve" "', argument " "1"" of type '" "gs::Reference< int > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< int > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Int_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (int )gs_Reference_Sl_int_Sg__retrieve((gs::Reference< int > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_Int_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< int > arg1 = (gs::Reference< int > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	int result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_Int_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Int_getValue" "', argument " "1"" of type '" "gs::Reference< int > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< int > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Int_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (int)gs_Reference_Sl_int_Sg__getValue((gs::Reference< int > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_int(static_cast< int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_Int(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< int > arg1 = (gs::Reference< int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_Int",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_int_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_Int" "', argument " "1"" of type '" "gs::Reference< int > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< int > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_Int_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_int_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_Long(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	long *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	long temp1 ;
	long val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_Long",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_long(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArchiveValueRecord_Long" "', argument " "1"" of type '" "long""'");
	}
	temp1 = static_cast< long >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_Long" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_Long" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< long > )new gs::ArchiveValueRecord< long >((long const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_long_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_Long(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< long > arg1 = (gs::ArchiveValueRecord< long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_Long",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_long_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_Long" "', argument " "1"" of type '" "gs::ArchiveValueRecord< long > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< long > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_Long_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_long_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_Long(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	long *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	long temp1 ;
	long val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< long > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_Long",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_long(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NPValueRecord_Long" "', argument " "1"" of type '" "long""'");
	}
	temp1 = static_cast< long >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_Long" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_Long" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< long >((long const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< long >(static_cast< const gs::ArchiveValueRecord< long >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_long_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Long__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_Long",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Long" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Long" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_Long" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< long > )new gs::Reference< long >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_long_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Long__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_Long",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Long" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Long" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_Long" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_Long" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< long > )new gs::Reference< long >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_long_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Long__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_Long",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Long" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Long" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_Long" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Long" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_Long" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Long" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< long > )new gs::Reference< long >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_long_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Long(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_Long__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_Long__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_Long__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_Long'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< long >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< long >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< long >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_Long_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< long > arg1 = (gs::Reference< long > ) 0 ;
	unsigned long arg2 ;
	long arg3 = (long ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_Long_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Long_restore" "', argument " "1"" of type '" "gs::Reference< long > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< long > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Long_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_long, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_Long_restore" "', argument " "3"" of type '" "long *""'");
	}
	arg3 = reinterpret_cast< long * >(argp3);
	{
	try {
	((gs::Reference< long > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_Long_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< long > arg1 = (gs::Reference< long > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	long *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_Long_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Long_retrieve" "', argument " "1"" of type '" "gs::Reference< long > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< long > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Long_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (long )gs_Reference_Sl_long_Sg__retrieve((gs::Reference< long > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_long, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_Long_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< long > arg1 = (gs::Reference< long > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	long result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_Long_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Long_getValue" "', argument " "1"" of type '" "gs::Reference< long > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< long > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Long_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (long)gs_Reference_Sl_long_Sg__getValue((gs::Reference< long > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_long(static_cast< long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_Long(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< long > arg1 = (gs::Reference< long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_Long",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_long_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_Long" "', argument " "1"" of type '" "gs::Reference< long > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< long > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_Long_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_long_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_LLong(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	long long *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	long long temp1 ;
	long long val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< long long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_LLong",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArchiveValueRecord_LLong" "', argument " "1"" of type '" "long long""'");
	}
	temp1 = static_cast< long long >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_LLong" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_LLong" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< long long > )new gs::ArchiveValueRecord< long long >((long long const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_long_long_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_LLong(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< long long > arg1 = (gs::ArchiveValueRecord< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_LLong",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_long_long_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_LLong" "', argument " "1"" of type '" "gs::ArchiveValueRecord< long long > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< long long > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_LLong_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_long_long_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_LLong(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	long long *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	long long temp1 ;
	long long val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< long long > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_LLong",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_long_SS_long(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NPValueRecord_LLong" "', argument " "1"" of type '" "long long""'");
	}
	temp1 = static_cast< long long >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_LLong" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_LLong" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< long long >((long long const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< long long >(static_cast< const gs::ArchiveValueRecord< long long >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_long_long_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LLong__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< long long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_LLong",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LLong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LLong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_LLong" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< long long > )new gs::Reference< long long >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_long_long_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LLong__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< long long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_LLong",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LLong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LLong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_LLong" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_LLong" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< long long > )new gs::Reference< long long >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_long_long_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LLong__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< long long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_LLong",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LLong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LLong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_LLong" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LLong" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_LLong" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LLong" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< long long > )new gs::Reference< long long >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_long_long_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LLong(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_LLong__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_LLong__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_LLong__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_LLong'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< long long >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< long long >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< long long >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_LLong_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< long long > arg1 = (gs::Reference< long long > ) 0 ;
	unsigned long arg2 ;
	long long arg3 = (long long ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_LLong_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LLong_restore" "', argument " "1"" of type '" "gs::Reference< long long > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< long long > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LLong_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_long_long, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_LLong_restore" "', argument " "3"" of type '" "long long *""'");
	}
	arg3 = reinterpret_cast< long long * >(argp3);
	{
	try {
	((gs::Reference< long long > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_LLong_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< long long > arg1 = (gs::Reference< long long > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	long long *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_LLong_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LLong_retrieve" "', argument " "1"" of type '" "gs::Reference< long long > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< long long > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LLong_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (long long )gs_Reference_Sl_long_SS_long_Sg__retrieve((gs::Reference< long long > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_long_long, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_LLong_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< long long > arg1 = (gs::Reference< long long > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	long long result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_LLong_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LLong_getValue" "', argument " "1"" of type '" "gs::Reference< long long > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< long long > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LLong_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (long long)gs_Reference_Sl_long_SS_long_Sg__getValue((gs::Reference< long long > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_long_SS_long(static_cast< long long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_LLong(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< long long > arg1 = (gs::Reference< long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_LLong",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_long_long_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_LLong" "', argument " "1"" of type '" "gs::Reference< long long > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< long long > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_LLong_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_long_long_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_UInt(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	unsigned int temp1 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< unsigned int > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_UInt",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArchiveValueRecord_UInt" "', argument " "1"" of type '" "unsigned int""'");
	}
	temp1 = static_cast< unsigned int >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_UInt" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_UInt" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< unsigned int > )new gs::ArchiveValueRecord< unsigned int >((unsigned int const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_int_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_UInt(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< unsigned int > arg1 = (gs::ArchiveValueRecord< unsigned int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_UInt",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_int_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_UInt" "', argument " "1"" of type '" "gs::ArchiveValueRecord< unsigned int > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< unsigned int > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_UInt_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_int_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_UInt(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned int *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	unsigned int temp1 ;
	unsigned int val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< unsigned int > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_UInt",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NPValueRecord_UInt" "', argument " "1"" of type '" "unsigned int""'");
	}
	temp1 = static_cast< unsigned int >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_UInt" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_UInt" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< unsigned int >((unsigned int const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< unsigned int >(static_cast< const gs::ArchiveValueRecord< unsigned int >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_int_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UInt__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< unsigned int > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_UInt",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UInt" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UInt" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_UInt" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< unsigned int > )new gs::Reference< unsigned int >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_unsigned_int_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UInt__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< unsigned int > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_UInt",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UInt" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UInt" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_UInt" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_UInt" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< unsigned int > )new gs::Reference< unsigned int >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_unsigned_int_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UInt__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< unsigned int > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_UInt",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_UInt" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UInt" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_UInt" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UInt" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_UInt" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_UInt" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< unsigned int > )new gs::Reference< unsigned int >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_unsigned_int_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_UInt(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_UInt__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_UInt__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_UInt__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_UInt'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< unsigned int >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< unsigned int >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< unsigned int >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_UInt_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned int > arg1 = (gs::Reference< unsigned int > ) 0 ;
	unsigned long arg2 ;
	unsigned int arg3 = (unsigned int ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_UInt_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UInt_restore" "', argument " "1"" of type '" "gs::Reference< unsigned int > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned int > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UInt_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_int, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_UInt_restore" "', argument " "3"" of type '" "unsigned int *""'");
	}
	arg3 = reinterpret_cast< unsigned int * >(argp3);
	{
	try {
	((gs::Reference< unsigned int > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_UInt_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned int > arg1 = (gs::Reference< unsigned int > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	unsigned int *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_UInt_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UInt_retrieve" "', argument " "1"" of type '" "gs::Reference< unsigned int > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned int > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UInt_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (unsigned int )gs_Reference_Sl_unsigned_SS_int_Sg__retrieve((gs::Reference< unsigned int > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_UInt_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned int > arg1 = (gs::Reference< unsigned int > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	unsigned int result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_UInt_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_int_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_UInt_getValue" "', argument " "1"" of type '" "gs::Reference< unsigned int > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned int > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_UInt_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (unsigned int)gs_Reference_Sl_unsigned_SS_int_Sg__getValue((gs::Reference< unsigned int > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_UInt(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned int > arg1 = (gs::Reference< unsigned int > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_UInt",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_int_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_UInt" "', argument " "1"" of type '" "gs::Reference< unsigned int > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned int > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_UInt_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_unsigned_int_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_ULong(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned long *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	unsigned long temp1 ;
	unsigned long val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< unsigned long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_ULong",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArchiveValueRecord_ULong" "', argument " "1"" of type '" "unsigned long""'");
	}
	temp1 = static_cast< unsigned long >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_ULong" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_ULong" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< unsigned long > )new gs::ArchiveValueRecord< unsigned long >((unsigned long const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_long_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_ULong(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< unsigned long > arg1 = (gs::ArchiveValueRecord< unsigned long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_ULong",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_long_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_ULong" "', argument " "1"" of type '" "gs::ArchiveValueRecord< unsigned long > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< unsigned long > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_ULong_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_long_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_ULong(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned long *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	unsigned long temp1 ;
	unsigned long val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< unsigned long > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_ULong",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NPValueRecord_ULong" "', argument " "1"" of type '" "unsigned long""'");
	}
	temp1 = static_cast< unsigned long >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_ULong" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_ULong" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< unsigned long >((unsigned long const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< unsigned long >(static_cast< const gs::ArchiveValueRecord< unsigned long >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_long_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ULong__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< unsigned long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_ULong",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_ULong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_ULong" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< unsigned long > )new gs::Reference< unsigned long >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_unsigned_long_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ULong__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< unsigned long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_ULong",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_ULong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_ULong" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_ULong" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< unsigned long > )new gs::Reference< unsigned long >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_unsigned_long_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ULong__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< unsigned long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_ULong",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_ULong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_ULong" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULong" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_ULong" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULong" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< unsigned long > )new gs::Reference< unsigned long >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_unsigned_long_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ULong(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_ULong__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_ULong__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_ULong__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_ULong'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< unsigned long >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< unsigned long >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< unsigned long >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_ULong_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned long > arg1 = (gs::Reference< unsigned long > ) 0 ;
	unsigned long arg2 ;
	unsigned long arg3 = (unsigned long ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_ULong_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_ULong_restore" "', argument " "1"" of type '" "gs::Reference< unsigned long > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned long > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_ULong_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_ULong_restore" "', argument " "3"" of type '" "unsigned long *""'");
	}
	arg3 = reinterpret_cast< unsigned long * >(argp3);
	{
	try {
	((gs::Reference< unsigned long > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_ULong_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned long > arg1 = (gs::Reference< unsigned long > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	unsigned long *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_ULong_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_ULong_retrieve" "', argument " "1"" of type '" "gs::Reference< unsigned long > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned long > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_ULong_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (unsigned long )gs_Reference_Sl_unsigned_SS_long_Sg__retrieve((gs::Reference< unsigned long > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_ULong_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned long > arg1 = (gs::Reference< unsigned long > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	unsigned long result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_ULong_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_ULong_getValue" "', argument " "1"" of type '" "gs::Reference< unsigned long > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned long > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_ULong_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (unsigned long)gs_Reference_Sl_unsigned_SS_long_Sg__getValue((gs::Reference< unsigned long > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_ULong(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned long > arg1 = (gs::Reference< unsigned long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_ULong",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_long_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_ULong" "', argument " "1"" of type '" "gs::Reference< unsigned long > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned long > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_ULong_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_unsigned_long_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_ULLong(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned long long *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	unsigned long long temp1 ;
	unsigned long long val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< unsigned long long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_ULLong",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArchiveValueRecord_ULLong" "', argument " "1"" of type '" "unsigned long long""'");
	}
	temp1 = static_cast< unsigned long long >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_ULLong" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_ULLong" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< unsigned long long > )new gs::ArchiveValueRecord< unsigned long long >((unsigned long long const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_long_long_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_ULLong(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< unsigned long long > arg1 = (gs::ArchiveValueRecord< unsigned long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_ULLong",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_long_long_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_ULLong" "', argument " "1"" of type '" "gs::ArchiveValueRecord< unsigned long long > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< unsigned long long > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_ULLong_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_long_long_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_ULLong(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	unsigned long long *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	unsigned long long temp1 ;
	unsigned long long val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< unsigned long long > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_ULLong",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NPValueRecord_ULLong" "', argument " "1"" of type '" "unsigned long long""'");
	}
	temp1 = static_cast< unsigned long long >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_ULLong" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_ULLong" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< unsigned long long >((unsigned long long const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< unsigned long long >(static_cast< const gs::ArchiveValueRecord< unsigned long long >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_unsigned_long_long_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ULLong__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< unsigned long long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_ULLong",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_ULLong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULLong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_ULLong" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< unsigned long long > )new gs::Reference< unsigned long long >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_unsigned_long_long_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ULLong__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< unsigned long long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_ULLong",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_ULLong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULLong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_ULLong" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_ULLong" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< unsigned long long > )new gs::Reference< unsigned long long >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_unsigned_long_long_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ULLong__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< unsigned long long > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_ULLong",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_ULLong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULLong" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_ULLong" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULLong" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_ULLong" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_ULLong" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< unsigned long long > )new gs::Reference< unsigned long long >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_unsigned_long_long_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_ULLong(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_ULLong__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_ULLong__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_ULLong__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_ULLong'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< unsigned long long >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< unsigned long long >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< unsigned long long >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_ULLong_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned long long > arg1 = (gs::Reference< unsigned long long > ) 0 ;
	unsigned long arg2 ;
	unsigned long long arg3 = (unsigned long long ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_ULLong_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_ULLong_restore" "', argument " "1"" of type '" "gs::Reference< unsigned long long > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned long long > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_ULLong_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_long_long, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_ULLong_restore" "', argument " "3"" of type '" "unsigned long long *""'");
	}
	arg3 = reinterpret_cast< unsigned long long * >(argp3);
	{
	try {
	((gs::Reference< unsigned long long > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_ULLong_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned long long > arg1 = (gs::Reference< unsigned long long > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	unsigned long long *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_ULLong_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_ULLong_retrieve" "', argument " "1"" of type '" "gs::Reference< unsigned long long > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned long long > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_ULLong_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (unsigned long long )gs_Reference_Sl_unsigned_SS_long_SS_long_Sg__retrieve((gs::Reference< unsigned long long > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long_long, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_ULLong_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned long long > arg1 = (gs::Reference< unsigned long long > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	unsigned long long result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_ULLong_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_long_long_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_ULLong_getValue" "', argument " "1"" of type '" "gs::Reference< unsigned long long > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned long long > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_ULLong_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (unsigned long long)gs_Reference_Sl_unsigned_SS_long_SS_long_Sg__getValue((gs::Reference< unsigned long long > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_ULLong(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< unsigned long long > arg1 = (gs::Reference< unsigned long long > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_ULLong",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_unsigned_long_long_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_ULLong" "', argument " "1"" of type '" "gs::Reference< unsigned long long > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< unsigned long long > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_ULLong_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_unsigned_long_long_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_Float(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	float *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	float temp1 ;
	float val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_Float",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_float(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArchiveValueRecord_Float" "', argument " "1"" of type '" "float""'");
	}
	temp1 = static_cast< float >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_Float" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_Float" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< float > )new gs::ArchiveValueRecord< float >((float const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_float_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_Float(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< float > arg1 = (gs::ArchiveValueRecord< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_Float",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_float_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_Float" "', argument " "1"" of type '" "gs::ArchiveValueRecord< float > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< float > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_Float_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_float_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_Float(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	float *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	float temp1 ;
	float val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< float > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_Float",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_float(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NPValueRecord_Float" "', argument " "1"" of type '" "float""'");
	}
	temp1 = static_cast< float >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_Float" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_Float" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< float >((float const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< float >(static_cast< const gs::ArchiveValueRecord< float >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_float_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Float__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_Float",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Float" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Float" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_Float" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< float > )new gs::Reference< float >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_float_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Float__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_Float",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Float" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Float" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_Float" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_Float" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< float > )new gs::Reference< float >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_float_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Float__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_Float",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Float" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Float" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_Float" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Float" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_Float" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Float" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< float > )new gs::Reference< float >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_float_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Float(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_Float__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_Float__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_Float__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_Float'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< float >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< float >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< float >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_Float_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< float > arg1 = (gs::Reference< float > ) 0 ;
	unsigned long arg2 ;
	float arg3 = (float ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_Float_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Float_restore" "', argument " "1"" of type '" "gs::Reference< float > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< float > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Float_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_float, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_Float_restore" "', argument " "3"" of type '" "float *""'");
	}
	arg3 = reinterpret_cast< float * >(argp3);
	{
	try {
	((gs::Reference< float > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_Float_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< float > arg1 = (gs::Reference< float > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	float *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_Float_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Float_retrieve" "', argument " "1"" of type '" "gs::Reference< float > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< float > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Float_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (float )gs_Reference_Sl_float_Sg__retrieve((gs::Reference< float > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_Float_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< float > arg1 = (gs::Reference< float > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	float result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_Float_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Float_getValue" "', argument " "1"" of type '" "gs::Reference< float > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< float > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Float_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (float)gs_Reference_Sl_float_Sg__getValue((gs::Reference< float > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_float(static_cast< float >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_Float(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< float > arg1 = (gs::Reference< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_Float",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_float_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_Float" "', argument " "1"" of type '" "gs::Reference< float > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< float > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_Float_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_float_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_Double(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	double temp1 ;
	double val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_Double",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArchiveValueRecord_Double" "', argument " "1"" of type '" "double""'");
	}
	temp1 = static_cast< double >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_Double" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_Double" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< double > )new gs::ArchiveValueRecord< double >((double const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_double_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_Double(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< double > arg1 = (gs::ArchiveValueRecord< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_Double",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_Double" "', argument " "1"" of type '" "gs::ArchiveValueRecord< double > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_Double_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_Double(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	double *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	double temp1 ;
	double val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< double > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_Double",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_double(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NPValueRecord_Double" "', argument " "1"" of type '" "double""'");
	}
	temp1 = static_cast< double >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_Double" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_Double" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< double >((double const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< double >(static_cast< const gs::ArchiveValueRecord< double >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_double_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Double__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_Double",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Double" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Double" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_Double" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< double > )new gs::Reference< double >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Double__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_Double",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Double" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Double" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_Double" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_Double" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< double > )new gs::Reference< double >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_double_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Double__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_Double",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_Double" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Double" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_Double" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Double" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_Double" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_Double" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< double > )new gs::Reference< double >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_Double(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_Double__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_Double__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_Double__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_Double'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< double >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< double >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< double >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_Double_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< double > arg1 = (gs::Reference< double > ) 0 ;
	unsigned long arg2 ;
	double arg3 = (double ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_Double_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Double_restore" "', argument " "1"" of type '" "gs::Reference< double > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< double > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Double_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_Double_restore" "', argument " "3"" of type '" "double *""'");
	}
	arg3 = reinterpret_cast< double * >(argp3);
	{
	try {
	((gs::Reference< double > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_Double_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< double > arg1 = (gs::Reference< double > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_Double_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Double_retrieve" "', argument " "1"" of type '" "gs::Reference< double > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< double > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Double_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (double )gs_Reference_Sl_double_Sg__retrieve((gs::Reference< double > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_Double_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< double > arg1 = (gs::Reference< double > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_Double_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_Double_getValue" "', argument " "1"" of type '" "gs::Reference< double > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< double > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_Double_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (double)gs_Reference_Sl_double_Sg__getValue((gs::Reference< double > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_double(static_cast< double >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_Double(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< double > arg1 = (gs::Reference< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_Double",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_Double" "', argument " "1"" of type '" "gs::Reference< double > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_Double_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_LDouble(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	long double *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< long double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_LDouble",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_long_double, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_LDouble" "', argument " "1"" of type '" "long double const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_LDouble" "', argument " "1"" of type '" "long double const &""'");
	}
	arg1 = reinterpret_cast< long double * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_LDouble" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_LDouble" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< long double > )new gs::ArchiveValueRecord< long double >((long double const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_long_double_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_LDouble(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< long double > arg1 = (gs::ArchiveValueRecord< long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_LDouble",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_long_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_LDouble" "', argument " "1"" of type '" "gs::ArchiveValueRecord< long double > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< long double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_LDouble_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_long_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_LDouble(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	long double *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< long double > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_LDouble",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_long_double, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_LDouble" "', argument " "1"" of type '" "long double const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_LDouble" "', argument " "1"" of type '" "long double const &""'");
	}
	arg1 = reinterpret_cast< long double * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_LDouble" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_LDouble" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< long double >((long double const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< long double >(static_cast< const gs::ArchiveValueRecord< long double >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_long_double_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LDouble__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< long double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_LDouble",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_LDouble" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< long double > )new gs::Reference< long double >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_long_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LDouble__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< long double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_LDouble",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_LDouble" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_LDouble" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< long double > )new gs::Reference< long double >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_long_double_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LDouble__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< long double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_LDouble",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_LDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_LDouble" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LDouble" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_LDouble" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_LDouble" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< long double > )new gs::Reference< long double >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_long_double_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_LDouble(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_LDouble__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_LDouble__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_LDouble__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_LDouble'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< long double >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< long double >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< long double >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_LDouble_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< long double > arg1 = (gs::Reference< long double > ) 0 ;
	unsigned long arg2 ;
	long double arg3 = (long double ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_LDouble_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LDouble_restore" "', argument " "1"" of type '" "gs::Reference< long double > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< long double > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LDouble_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_long_double, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_LDouble_restore" "', argument " "3"" of type '" "long double *""'");
	}
	arg3 = reinterpret_cast< long double * >(argp3);
	{
	try {
	((gs::Reference< long double > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_LDouble_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< long double > arg1 = (gs::Reference< long double > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	long double *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_LDouble_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LDouble_retrieve" "', argument " "1"" of type '" "gs::Reference< long double > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< long double > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LDouble_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (long double )gs_Reference_Sl_long_SS_double_Sg__retrieve((gs::Reference< long double > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_long_double, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_LDouble_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< long double > arg1 = (gs::Reference< long double > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	long double result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_LDouble_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_LDouble_getValue" "', argument " "1"" of type '" "gs::Reference< long double > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< long double > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_LDouble_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (long double)gs_Reference_Sl_long_SS_double_Sg__getValue((gs::Reference< long double > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new long double(static_cast< const long double& >(result))), SWIGTYPE_p_long_double, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_LDouble(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< long double > arg1 = (gs::Reference< long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_LDouble",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_long_double_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_LDouble" "', argument " "1"" of type '" "gs::Reference< long double > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< long double > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_LDouble_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_long_double_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_CFloat(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::complex< float > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	std::complex< float > temp1 ;
	std::complex< float > val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::complex< float > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_CFloat",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_std_complex_Sl_float_Sg_(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArchiveValueRecord_CFloat" "', argument " "1"" of type '" "std::complex< float >""'");
	}
	temp1 = static_cast< std::complex< float > >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_CFloat" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_CFloat" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::complex< float > > )new gs::ArchiveValueRecord< std::complex< float > >((std::complex< float > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__complexT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_CFloat(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::complex< float > > arg1 = (gs::ArchiveValueRecord< std::complex< float > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_CFloat",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__complexT_float_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_CFloat" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::complex< float > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::complex< float > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_CFloat_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__complexT_float_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_CFloat(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::complex< float > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	std::complex< float > temp1 ;
	std::complex< float > val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::complex< float > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_CFloat",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_std_complex_Sl_float_Sg_(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NPValueRecord_CFloat" "', argument " "1"" of type '" "std::complex< float >""'");
	}
	temp1 = static_cast< std::complex< float > >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_CFloat" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_CFloat" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::complex< float > >((std::complex< float > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::complex< float > >(static_cast< const gs::ArchiveValueRecord< std::complex< float > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__complexT_float_t_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CFloat__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::complex< float > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_CFloat",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CFloat" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CFloat" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_CFloat" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::complex< float > > )new gs::Reference< std::complex< float > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__complexT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CFloat__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::complex< float > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_CFloat",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CFloat" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CFloat" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_CFloat" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_CFloat" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::complex< float > > )new gs::Reference< std::complex< float > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__complexT_float_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CFloat__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::complex< float > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_CFloat",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CFloat" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CFloat" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_CFloat" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CFloat" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_CFloat" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CFloat" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::complex< float > > )new gs::Reference< std::complex< float > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__complexT_float_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CFloat(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_CFloat__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_CFloat__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_CFloat__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_CFloat'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::complex< float > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::complex< float > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::complex< float > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_CFloat_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::complex< float > > arg1 = (gs::Reference< std::complex< float > > ) 0 ;
	unsigned long arg2 ;
	std::complex< float > arg3 = (std::complex< float > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_CFloat_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__complexT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CFloat_restore" "', argument " "1"" of type '" "gs::Reference< std::complex< float > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::complex< float > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CFloat_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__complexT_float_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_CFloat_restore" "', argument " "3"" of type '" "std::complex< float > *""'");
	}
	arg3 = reinterpret_cast< std::complex< float > * >(argp3);
	{
	try {
	((gs::Reference< std::complex< float > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_CFloat_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::complex< float > > arg1 = (gs::Reference< std::complex< float > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::complex< float > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_CFloat_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__complexT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CFloat_retrieve" "', argument " "1"" of type '" "gs::Reference< std::complex< float > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::complex< float > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CFloat_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::complex< float > )gs_Reference_Sl_std_complex_Sl_float_Sg__Sg__retrieve((gs::Reference< std::complex< float > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__complexT_float_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_CFloat_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::complex< float > > arg1 = (gs::Reference< std::complex< float > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::complex< float > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_CFloat_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__complexT_float_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CFloat_getValue" "', argument " "1"" of type '" "gs::Reference< std::complex< float > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::complex< float > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CFloat_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_complex_Sl_float_Sg__Sg__getValue((gs::Reference< std::complex< float > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_std_complex_Sl_float_Sg_(static_cast< std::complex<float> >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_CFloat(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::complex< float > > arg1 = (gs::Reference< std::complex< float > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_CFloat",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__complexT_float_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_CFloat" "', argument " "1"" of type '" "gs::Reference< std::complex< float > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::complex< float > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_CFloat_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__complexT_float_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_CDouble(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::complex< double > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	std::complex< double > temp1 ;
	std::complex< double > val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::complex< double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_CDouble",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ArchiveValueRecord_CDouble" "', argument " "1"" of type '" "std::complex< double >""'");
	}
	temp1 = static_cast< std::complex< double > >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_CDouble" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_CDouble" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::complex< double > > )new gs::ArchiveValueRecord< std::complex< double > >((std::complex< double > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__complexT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_CDouble(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::complex< double > > arg1 = (gs::ArchiveValueRecord< std::complex< double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_CDouble",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__complexT_double_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_CDouble" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::complex< double > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::complex< double > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_CDouble_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__complexT_double_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_CDouble(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::complex< double > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	std::complex< double > temp1 ;
	std::complex< double > val1 ;
	int ecode1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::complex< double > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_CDouble",&obj0,&obj1,&obj2)) SWIG_fail;
	ecode1 = SWIG_AsVal_std_complex_Sl_double_Sg_(obj0, &val1);
	if (!SWIG_IsOK(ecode1)) {
	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "NPValueRecord_CDouble" "', argument " "1"" of type '" "std::complex< double >""'");
	}
	temp1 = static_cast< std::complex< double > >(val1);
	arg1 = &temp1;
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_CDouble" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_CDouble" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::complex< double > >((std::complex< double > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::complex< double > >(static_cast< const gs::ArchiveValueRecord< std::complex< double > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__complexT_double_t_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CDouble__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::complex< double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_CDouble",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_CDouble" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::complex< double > > )new gs::Reference< std::complex< double > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__complexT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CDouble__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::complex< double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_CDouble",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_CDouble" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_CDouble" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::complex< double > > )new gs::Reference< std::complex< double > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__complexT_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CDouble__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::complex< double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_CDouble",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_CDouble" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CDouble" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_CDouble" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CDouble" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::complex< double > > )new gs::Reference< std::complex< double > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__complexT_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CDouble(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_CDouble__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_CDouble__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_CDouble__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_CDouble'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::complex< double > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::complex< double > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::complex< double > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_CDouble_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::complex< double > > arg1 = (gs::Reference< std::complex< double > > ) 0 ;
	unsigned long arg2 ;
	std::complex< double > arg3 = (std::complex< double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_CDouble_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__complexT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CDouble_restore" "', argument " "1"" of type '" "gs::Reference< std::complex< double > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::complex< double > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CDouble_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__complexT_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_CDouble_restore" "', argument " "3"" of type '" "std::complex< double > *""'");
	}
	arg3 = reinterpret_cast< std::complex< double > * >(argp3);
	{
	try {
	((gs::Reference< std::complex< double > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_CDouble_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::complex< double > > arg1 = (gs::Reference< std::complex< double > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::complex< double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_CDouble_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__complexT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CDouble_retrieve" "', argument " "1"" of type '" "gs::Reference< std::complex< double > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::complex< double > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CDouble_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::complex< double > )gs_Reference_Sl_std_complex_Sl_double_Sg__Sg__retrieve((gs::Reference< std::complex< double > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__complexT_double_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_CDouble_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::complex< double > > arg1 = (gs::Reference< std::complex< double > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::complex< double > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_CDouble_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__complexT_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CDouble_getValue" "', argument " "1"" of type '" "gs::Reference< std::complex< double > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::complex< double > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CDouble_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_complex_Sl_double_Sg__Sg__getValue((gs::Reference< std::complex< double > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_CDouble(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::complex< double > > arg1 = (gs::Reference< std::complex< double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_CDouble",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__complexT_double_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_CDouble" "', argument " "1"" of type '" "gs::Reference< std::complex< double > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::complex< double > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_CDouble_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__complexT_double_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_CLDouble(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::complex< long double > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::complex< long double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_CLDouble",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__complexT_long_double_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_CLDouble" "', argument " "1"" of type '" "std::complex< long double > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_CLDouble" "', argument " "1"" of type '" "std::complex< long double > const &""'");
	}
	arg1 = reinterpret_cast< std::complex< long double > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_CLDouble" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_CLDouble" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::complex< long double > > )new gs::ArchiveValueRecord< std::complex< long double > >((std::complex< long double > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__complexT_long_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_CLDouble(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::complex< long double > > arg1 = (gs::ArchiveValueRecord< std::complex< long double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_CLDouble",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__complexT_long_double_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_CLDouble" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::complex< long double > > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::complex< long double > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_CLDouble_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__complexT_long_double_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_CLDouble(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::complex< long double > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::complex< long double > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_CLDouble",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__complexT_long_double_t, 0 \| 0);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_CLDouble" "', argument " "1"" of type '" "std::complex< long double > const &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_CLDouble" "', argument " "1"" of type '" "std::complex< long double > const &""'");
	}
	arg1 = reinterpret_cast< std::complex< long double > * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_CLDouble" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_CLDouble" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::complex< long double > >((std::complex< long double > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::complex< long double > >(static_cast< const gs::ArchiveValueRecord< std::complex< long double > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__complexT_long_double_t_t, SWIG_POINTER_OWN \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CLDouble__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::complex< long double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_CLDouble",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CLDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CLDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_CLDouble" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::complex< long double > > )new gs::Reference< std::complex< long double > >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__complexT_long_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CLDouble__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::complex< long double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_CLDouble",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CLDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CLDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_CLDouble" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_CLDouble" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::complex< long double > > )new gs::Reference< std::complex< long double > >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__complexT_long_double_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CLDouble__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::complex< long double > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_CLDouble",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_CLDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CLDouble" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_CLDouble" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CLDouble" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_CLDouble" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_CLDouble" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::complex< long double > > )new gs::Reference< std::complex< long double > >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__complexT_long_double_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_CLDouble(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_CLDouble__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_CLDouble__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_CLDouble__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_CLDouble'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::complex< long double > >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::complex< long double > >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::complex< long double > >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_CLDouble_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::complex< long double > > arg1 = (gs::Reference< std::complex< long double > > ) 0 ;
	unsigned long arg2 ;
	std::complex< long double > arg3 = (std::complex< long double > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_CLDouble_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__complexT_long_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CLDouble_restore" "', argument " "1"" of type '" "gs::Reference< std::complex< long double > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::complex< long double > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CLDouble_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__complexT_long_double_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_CLDouble_restore" "', argument " "3"" of type '" "std::complex< long double > *""'");
	}
	arg3 = reinterpret_cast< std::complex< long double > * >(argp3);
	{
	try {
	((gs::Reference< std::complex< long double > > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_CLDouble_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::complex< long double > > arg1 = (gs::Reference< std::complex< long double > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::complex< long double > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_CLDouble_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__complexT_long_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CLDouble_retrieve" "', argument " "1"" of type '" "gs::Reference< std::complex< long double > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::complex< long double > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CLDouble_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::complex< long double > )gs_Reference_Sl_std_complex_Sl_long_SS_double_Sg__Sg__retrieve((gs::Reference< std::complex< long double > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__complexT_long_double_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_CLDouble_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::complex< long double > > arg1 = (gs::Reference< std::complex< long double > > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::complex< long double > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_CLDouble_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__complexT_long_double_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_CLDouble_getValue" "', argument " "1"" of type '" "gs::Reference< std::complex< long double > > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::complex< long double > > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_CLDouble_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_complex_Sl_long_SS_double_Sg__Sg__getValue((gs::Reference< std::complex< long double > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new std::complex< long double >(static_cast< const std::complex< long double >& >(result))), SWIGTYPE_p_std__complexT_long_double_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_CLDouble(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::complex< long double > > arg1 = (gs::Reference< std::complex< long double > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_CLDouble",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__complexT_long_double_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_CLDouble" "', argument " "1"" of type '" "gs::Reference< std::complex< long double > > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::complex< long double > > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_CLDouble_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__complexT_long_double_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_ArchiveValueRecord_String(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::basic_string< char,std::char_traits< char >,std::allocator< char > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::ArchiveValueRecord< std::string > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_ArchiveValueRecord_String",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::basic_string<char> ptr = (std::basic_string<char> )0;
	res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArchiveValueRecord_String" "', argument " "1"" of type '" "std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArchiveValueRecord_String" "', argument " "1"" of type '" "std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ArchiveValueRecord_String" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ArchiveValueRecord_String" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::ArchiveValueRecord< std::string > )new gs::ArchiveValueRecord< std::string >((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ArchiveValueRecordT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_ArchiveValueRecord_String(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::ArchiveValueRecord< std::string > arg1 = (gs::ArchiveValueRecord< std::string > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_ArchiveValueRecord_String",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ArchiveValueRecordT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArchiveValueRecord_String" "', argument " "1"" of type '" "gs::ArchiveValueRecord< std::string > *""'");
	}
	arg1 = reinterpret_cast< gs::ArchiveValueRecord< std::string > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject ArchiveValueRecord_String_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ArchiveValueRecordT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_NPValueRecord_String(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	std::basic_string< char,std::char_traits< char >,std::allocator< char > > *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 = SWIG_OLDOBJ ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	SwigValueWrapper< gs::ArchiveValueRecord< std::basic_string< char,std::char_traits< char >,std::allocator< char > > > > result;

	if (!PyArg_ParseTuple(args,(char *)"OOO:NPValueRecord_String",&obj0,&obj1,&obj2)) SWIG_fail;
	{
	std::basic_string<char> ptr = (std::basic_string<char> )0;
	res1 = SWIG_AsPtr_std_basic_string_Sl_char_Sg_(obj0, &ptr);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NPValueRecord_String" "', argument " "1"" of type '" "std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
	}
	if (!ptr) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NPValueRecord_String" "', argument " "1"" of type '" "std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &""'");
	}
	arg1 = ptr;
	}
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NPValueRecord_String" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NPValueRecord_String" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = gs::SWIGTEMPLATEDISAMBIGUATOR ValueRecord< std::string >((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)arg1,(char const )arg2,(char const *)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj((new gs::ArchiveValueRecord< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >(static_cast< const gs::ArchiveValueRecord< std::basic_string< char,std::char_traits< char >,std::allocator< char > > >& >(result))), SWIGTYPE_p_gs__ArchiveValueRecordT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t, SWIG_POINTER_OWN \| 0 );
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (SWIG_IsNewObj(res1)) delete arg1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_String__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	unsigned long long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::Reference< std::string > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_Ref_String",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_String" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_String" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Ref_String" "', argument " "2"" of type '" "unsigned long long""'");
	}
	arg2 = static_cast< unsigned long long >(val2);
	{
	try {
	result = (gs::Reference< std::string > )new gs::Reference< std::string >(arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_String__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::string > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_String",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_String" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_String" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_String" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_String" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::Reference< std::string > )new gs::Reference< std::string >(arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t, SWIG_POINTER_NEW \| 0 );
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_String__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::AbsArchive *arg1 = 0 ;
	gs::SearchSpecifier *arg2 = 0 ;
	gs::SearchSpecifier *arg3 = 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	void *argp2 = 0 ;
	int res2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::Reference< std::string > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_Ref_String",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_gs__AbsArchive, 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Ref_String" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	if (!argp1) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_String" "', argument " "1"" of type '" "gs::AbsArchive &""'");
	}
	arg1 = reinterpret_cast< gs::AbsArchive * >(argp1);
	res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Ref_String" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp2) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_String" "', argument " "2"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg2 = reinterpret_cast< gs::SearchSpecifier * >(argp2);
	res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_gs__SearchSpecifier, 0 \| 0);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Ref_String" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	if (!argp3) {
	SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Ref_String" "', argument " "3"" of type '" "gs::SearchSpecifier const &""'");
	}
	arg3 = reinterpret_cast< gs::SearchSpecifier * >(argp3);
	{
	try {
	result = (gs::Reference< std::string > )new gs::Reference< std::string >(arg1,(gs::SearchSpecifier const &)arg2,(gs::SearchSpecifier const &)arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__ReferenceT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t, SWIG_POINTER_NEW \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_Ref_String(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[4] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 3) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_Ref_String__SWIG_0(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_gs__SearchSpecifier, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_String__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 3) {
	int _v;
	void *vptr = 0;
	int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gs__AbsArchive, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_Ref_String__SWIG_1(self, args);
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_Ref_String'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::Reference< std::string >::Reference(gs::AbsArchive &,unsigned long long const)\n"
	" gs::Reference< std::string >::Reference(gs::AbsArchive &,char const ,char const )\n"
	" gs::Reference< std::string >::Reference(gs::AbsArchive &,gs::SearchSpecifier const &,gs::SearchSpecifier const &)\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_Ref_String_restore(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::string > arg1 = (gs::Reference< std::string > ) 0 ;
	unsigned long arg2 ;
	std::basic_string< char,std::char_traits< char >,std::allocator< char > > arg3 = (std::basic_string< char,std::char_traits< char >,std::allocator< char > > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	void *argp3 = 0 ;
	int res3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:Ref_String_restore",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_String_restore" "', argument " "1"" of type '" "gs::Reference< std::string > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::string > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_String_restore" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ref_String_restore" "', argument " "3"" of type '" "std::basic_string< char,std::char_traits< char >,std::allocator< char > > *""'");
	}
	arg3 = reinterpret_cast< std::basic_string< char,std::char_traits< char >,std::allocator< char > > * >(argp3);
	{
	try {
	((gs::Reference< std::string > const *)arg1)->restore(arg2,arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_String_retrieve(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::string > arg1 = (gs::Reference< std::string > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::basic_string< char,std::char_traits< char >,std::allocator< char > > *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_String_retrieve",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_String_retrieve" "', argument " "1"" of type '" "gs::Reference< std::string > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::string > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_String_retrieve" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = (std::basic_string< char,std::char_traits< char >,std::allocator< char > > )gs_Reference_Sl_std_string_Sg__retrieve((gs::Reference< std::basic_string< char,std::char_traits< char >,std::allocator< char > > > const )arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, SWIG_POINTER_OWN \| 0 );
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_Ref_String_getValue(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::string > arg1 = (gs::Reference< std::string > ) 0 ;
	unsigned long arg2 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	unsigned long val2 ;
	int ecode2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	std::basic_string< char,std::char_traits< char >,std::allocator< char > > result;

	if (!PyArg_ParseTuple(args,(char *)"OO:Ref_String_getValue",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ref_String_getValue" "', argument " "1"" of type '" "gs::Reference< std::string > const *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::string > * >(argp1);
	ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
	if (!SWIG_IsOK(ecode2)) {
	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ref_String_getValue" "', argument " "2"" of type '" "unsigned long""'");
	}
	arg2 = static_cast< unsigned long >(val2);
	{
	try {
	result = gs_Reference_Sl_std_string_Sg__getValue((gs::Reference< std::basic_string< char,std::char_traits< char >,std::allocator< char > > > const *)arg1,arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_From_std_basic_string_Sl_char_Sg_(static_cast< std::basic_string<char> >(result));
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_delete_Ref_String(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::Reference< std::string > arg1 = (gs::Reference< std::string > ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_Ref_String",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__ReferenceT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ref_String" "', argument " "1"" of type '" "gs::Reference< std::string > *""'");
	}
	arg1 = reinterpret_cast< gs::Reference< std::string > * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject Ref_String_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__ReferenceT_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t_t, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_BinaryFileArchive__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char arg1 = (char ) 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	int res1 ;
	char *buf1 = 0 ;
	int alloc1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	gs::BinaryFileArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_BinaryFileArchive",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinaryFileArchive" "', argument " "1"" of type '" "char const *""'");
	}
	arg1 = reinterpret_cast< char * >(buf1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BinaryFileArchive" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BinaryFileArchive" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BinaryFileArchive" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_BinaryFileArchive" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	result = (gs::BinaryFileArchive )new gs::BinaryFileArchive((char const )arg1,(char const )arg2,(char const )arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__BinaryFileArchive, SWIG_POINTER_NEW \| 0 );
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_BinaryFileArchive__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char arg1 = (char ) 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	unsigned int arg4 ;
	int res1 ;
	char *buf1 = 0 ;
	int alloc1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	gs::BinaryFileArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_BinaryFileArchive",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinaryFileArchive" "', argument " "1"" of type '" "char const *""'");
	}
	arg1 = reinterpret_cast< char * >(buf1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BinaryFileArchive" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BinaryFileArchive" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BinaryFileArchive" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	result = (gs::BinaryFileArchive )new gs::BinaryFileArchive((char const )arg1,(char const )arg2,(char const )arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__BinaryFileArchive, SWIG_POINTER_NEW \| 0 );
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_BinaryFileArchive__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char arg1 = (char ) 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 ;
	char *buf1 = 0 ;
	int alloc1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::BinaryFileArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_BinaryFileArchive",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinaryFileArchive" "', argument " "1"" of type '" "char const *""'");
	}
	arg1 = reinterpret_cast< char * >(buf1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BinaryFileArchive" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BinaryFileArchive" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::BinaryFileArchive )new gs::BinaryFileArchive((char const )arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__BinaryFileArchive, SWIG_POINTER_NEW \| 0 );
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_BinaryFileArchive__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char arg1 = (char ) 0 ;
	char arg2 = (char ) 0 ;
	int res1 ;
	char *buf1 = 0 ;
	int alloc1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::BinaryFileArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_BinaryFileArchive",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BinaryFileArchive" "', argument " "1"" of type '" "char const *""'");
	}
	arg1 = reinterpret_cast< char * >(buf1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BinaryFileArchive" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	{
	try {
	result = (gs::BinaryFileArchive )new gs::BinaryFileArchive((char const )arg1,(char const *)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__BinaryFileArchive, SWIG_POINTER_NEW \| 0 );
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return resultobj;
	fail:
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_BinaryFileArchive(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[6] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 5) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_BinaryFileArchive__SWIG_3(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_BinaryFileArchive__SWIG_2(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_BinaryFileArchive__SWIG_1(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_BinaryFileArchive__SWIG_0(self, args);
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_BinaryFileArchive'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::BinaryFileArchive::BinaryFileArchive(char const ,char const ,char const *,unsigned int,unsigned int)\n"
	" gs::BinaryFileArchive::BinaryFileArchive(char const ,char const ,char const *,unsigned int)\n"
	" gs::BinaryFileArchive::BinaryFileArchive(char const ,char const ,char const *)\n"
	" gs::BinaryFileArchive::BinaryFileArchive(char const ,char const )\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_BinaryFileArchive(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryFileArchive arg1 = (gs::BinaryFileArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_BinaryFileArchive",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryFileArchive, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BinaryFileArchive" "', argument " "1"" of type '" "gs::BinaryFileArchive *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryFileArchive * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_BinaryFileArchive_flush(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::BinaryFileArchive arg1 = (gs::BinaryFileArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:BinaryFileArchive_flush",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__BinaryFileArchive, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BinaryFileArchive_flush" "', argument " "1"" of type '" "gs::BinaryFileArchive *""'");
	}
	arg1 = reinterpret_cast< gs::BinaryFileArchive * >(argp1);
	{
	try {
	(arg1)->flush();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject BinaryFileArchive_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__BinaryFileArchive, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	SWIGINTERN PyObject _wrap_new_MultiFileArchive__SWIG_0(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char arg1 = (char ) 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	unsigned int arg6 ;
	int res1 ;
	char *buf1 = 0 ;
	int alloc1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	unsigned int val6 ;
	int ecode6 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	PyObject * obj5 = 0 ;
	gs::MultiFileArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:new_MultiFileArchive",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MultiFileArchive" "', argument " "1"" of type '" "char const *""'");
	}
	arg1 = reinterpret_cast< char * >(buf1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MultiFileArchive" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MultiFileArchive" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MultiFileArchive" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MultiFileArchive" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
	if (!SWIG_IsOK(ecode6)) {
	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_MultiFileArchive" "', argument " "6"" of type '" "unsigned int""'");
	}
	arg6 = static_cast< unsigned int >(val6);
	{
	try {
	result = (gs::MultiFileArchive )new gs::MultiFileArchive((char const )arg1,(char const )arg2,(char const )arg3,arg4,arg5,arg6);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__MultiFileArchive, SWIG_POINTER_NEW \| 0 );
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_MultiFileArchive__SWIG_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char arg1 = (char ) 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	unsigned int arg4 ;
	unsigned int arg5 ;
	int res1 ;
	char *buf1 = 0 ;
	int alloc1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	unsigned int val5 ;
	int ecode5 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	PyObject * obj4 = 0 ;
	gs::MultiFileArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOOO:new_MultiFileArchive",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MultiFileArchive" "', argument " "1"" of type '" "char const *""'");
	}
	arg1 = reinterpret_cast< char * >(buf1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MultiFileArchive" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MultiFileArchive" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MultiFileArchive" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
	if (!SWIG_IsOK(ecode5)) {
	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MultiFileArchive" "', argument " "5"" of type '" "unsigned int""'");
	}
	arg5 = static_cast< unsigned int >(val5);
	{
	try {
	result = (gs::MultiFileArchive )new gs::MultiFileArchive((char const )arg1,(char const )arg2,(char const )arg3,arg4,arg5);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__MultiFileArchive, SWIG_POINTER_NEW \| 0 );
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_MultiFileArchive__SWIG_2(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char arg1 = (char ) 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	unsigned int arg4 ;
	int res1 ;
	char *buf1 = 0 ;
	int alloc1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	unsigned int val4 ;
	int ecode4 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	PyObject * obj3 = 0 ;
	gs::MultiFileArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOOO:new_MultiFileArchive",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MultiFileArchive" "', argument " "1"" of type '" "char const *""'");
	}
	arg1 = reinterpret_cast< char * >(buf1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MultiFileArchive" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MultiFileArchive" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
	if (!SWIG_IsOK(ecode4)) {
	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MultiFileArchive" "', argument " "4"" of type '" "unsigned int""'");
	}
	arg4 = static_cast< unsigned int >(val4);
	{
	try {
	result = (gs::MultiFileArchive )new gs::MultiFileArchive((char const )arg1,(char const )arg2,(char const )arg3,arg4);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__MultiFileArchive, SWIG_POINTER_NEW \| 0 );
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_MultiFileArchive__SWIG_3(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char arg1 = (char ) 0 ;
	char arg2 = (char ) 0 ;
	char arg3 = (char ) 0 ;
	int res1 ;
	char *buf1 = 0 ;
	int alloc1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	int res3 ;
	char *buf3 = 0 ;
	int alloc3 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	PyObject * obj2 = 0 ;
	gs::MultiFileArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OOO:new_MultiFileArchive",&obj0,&obj1,&obj2)) SWIG_fail;
	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MultiFileArchive" "', argument " "1"" of type '" "char const *""'");
	}
	arg1 = reinterpret_cast< char * >(buf1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MultiFileArchive" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
	if (!SWIG_IsOK(res3)) {
	SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MultiFileArchive" "', argument " "3"" of type '" "char const *""'");
	}
	arg3 = reinterpret_cast< char * >(buf3);
	{
	try {
	result = (gs::MultiFileArchive )new gs::MultiFileArchive((char const )arg1,(char const )arg2,(char const )arg3);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__MultiFileArchive, SWIG_POINTER_NEW \| 0 );
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return resultobj;
	fail:
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_MultiFileArchive__SWIG_4(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	char arg1 = (char ) 0 ;
	char arg2 = (char ) 0 ;
	int res1 ;
	char *buf1 = 0 ;
	int alloc1 = 0 ;
	int res2 ;
	char *buf2 = 0 ;
	int alloc2 = 0 ;
	PyObject * obj0 = 0 ;
	PyObject * obj1 = 0 ;
	gs::MultiFileArchive *result = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"OO:new_MultiFileArchive",&obj0,&obj1)) SWIG_fail;
	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MultiFileArchive" "', argument " "1"" of type '" "char const *""'");
	}
	arg1 = reinterpret_cast< char * >(buf1);
	res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
	if (!SWIG_IsOK(res2)) {
	SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MultiFileArchive" "', argument " "2"" of type '" "char const *""'");
	}
	arg2 = reinterpret_cast< char * >(buf2);
	{
	try {
	result = (gs::MultiFileArchive )new gs::MultiFileArchive((char const )arg1,(char const *)arg2);
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gs__MultiFileArchive, SWIG_POINTER_NEW \| 0 );
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return resultobj;
	fail:
	if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
	if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
	return NULL;
	}


	SWIGINTERN PyObject _wrap_new_MultiFileArchive(PyObject self, PyObject *args) {
	Py_ssize_t argc;
	PyObject *argv[7] = {
	0
	};
	Py_ssize_t ii;

	if (!PyTuple_Check(args)) SWIG_fail;
	argc = args ? PyObject_Length(args) : 0;
	for (ii = 0; (ii < 6) && (ii < argc); ii++) {
	argv[ii] = PyTuple_GET_ITEM(args,ii);
	}
	if (argc == 2) {
	int _v;
	int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_MultiFileArchive__SWIG_4(self, args);
	}
	}
	}
	if (argc == 3) {
	int _v;
	int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	return _wrap_new_MultiFileArchive__SWIG_3(self, args);
	}
	}
	}
	}
	if (argc == 4) {
	int _v;
	int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_MultiFileArchive__SWIG_2(self, args);
	}
	}
	}
	}
	}
	if (argc == 5) {
	int _v;
	int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_MultiFileArchive__SWIG_1(self, args);
	}
	}
	}
	}
	}
	}
	if (argc == 6) {
	int _v;
	int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
	_v = SWIG_CheckState(res);
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	{
	int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
	_v = SWIG_CheckState(res);
	}
	if (_v) {
	return _wrap_new_MultiFileArchive__SWIG_0(self, args);
	}
	}
	}
	}
	}
	}
	}

	fail:
	SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_MultiFileArchive'.\n"
	" Possible C/C++ prototypes are:\n"
	" gs::MultiFileArchive::MultiFileArchive(char const ,char const ,char const *,unsigned int,unsigned int,unsigned int)\n"
	" gs::MultiFileArchive::MultiFileArchive(char const ,char const ,char const *,unsigned int,unsigned int)\n"
	" gs::MultiFileArchive::MultiFileArchive(char const ,char const ,char const *,unsigned int)\n"
	" gs::MultiFileArchive::MultiFileArchive(char const ,char const ,char const *)\n"
	" gs::MultiFileArchive::MultiFileArchive(char const ,char const )\n");
	return 0;
	}


	SWIGINTERN PyObject _wrap_delete_MultiFileArchive(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::MultiFileArchive arg1 = (gs::MultiFileArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:delete_MultiFileArchive",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__MultiFileArchive, SWIG_POINTER_DISOWN \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MultiFileArchive" "', argument " "1"" of type '" "gs::MultiFileArchive *""'");
	}
	arg1 = reinterpret_cast< gs::MultiFileArchive * >(argp1);
	{
	try {
	delete arg1;
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject _wrap_MultiFileArchive_flush(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *resultobj = 0;
	gs::MultiFileArchive arg1 = (gs::MultiFileArchive ) 0 ;
	void *argp1 = 0 ;
	int res1 = 0 ;
	PyObject * obj0 = 0 ;

	if (!PyArg_ParseTuple(args,(char *)"O:MultiFileArchive_flush",&obj0)) SWIG_fail;
	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gs__MultiFileArchive, 0 \| 0 );
	if (!SWIG_IsOK(res1)) {
	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultiFileArchive_flush" "', argument " "1"" of type '" "gs::MultiFileArchive *""'");
	}
	arg1 = reinterpret_cast< gs::MultiFileArchive * >(argp1);
	{
	try {
	(arg1)->flush();
	} catch (const std::exception& e) {
	SWIG_exception(SWIG_RuntimeError, e.what());
	}
	}
	resultobj = SWIG_Py_Void();
	return resultobj;
	fail:
	return NULL;
	}


	SWIGINTERN PyObject MultiFileArchive_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	PyObject *obj;
	if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
	SWIG_TypeNewClientData(SWIGTYPE_p_gs__MultiFileArchive, SWIG_NewClientData(obj));
	return SWIG_Py_Void();
	}

	static PyMethodDef SwigMethods[] = {
	{ (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
	{ (char *)"delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_VARARGS, NULL},
	{ (char *)"SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_VARARGS, NULL},
	{ (char *)"SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
	{ (char *)"SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
	{ (char *)"SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
	{ (char *)"SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, NULL},
	{ (char *)"SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_VARARGS, NULL},
	{ (char *)"SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_VARARGS, NULL},
	{ (char *)"SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_VARARGS, NULL},
	{ (char *)"SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_VARARGS, NULL},
	{ (char *)"SwigPyIterator_advance", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
	{ (char *)"SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
	{ (char *)"SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
	{ (char *)"SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
	{ (char *)"SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
	{ (char *)"SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
	{ (char *)"SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
	{ (char *)"SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_VARARGS, NULL},
	{ (char *)"string_length", _wrap_string_length, METH_VARARGS, NULL},
	{ (char *)"string_max_size", _wrap_string_max_size, METH_VARARGS, NULL},
	{ (char *)"string_capacity", _wrap_string_capacity, METH_VARARGS, NULL},
	{ (char *)"string_reserve", _wrap_string_reserve, METH_VARARGS, NULL},
	{ (char *)"string_copy", _wrap_string_copy, METH_VARARGS, NULL},
	{ (char *)"string_c_str", _wrap_string_c_str, METH_VARARGS, NULL},
	{ (char *)"string_find", _wrap_string_find, METH_VARARGS, NULL},
	{ (char *)"string_rfind", _wrap_string_rfind, METH_VARARGS, NULL},
	{ (char *)"string_find_first_of", _wrap_string_find_first_of, METH_VARARGS, NULL},
	{ (char *)"string_find_last_of", _wrap_string_find_last_of, METH_VARARGS, NULL},
	{ (char *)"string_find_first_not_of", _wrap_string_find_first_not_of, METH_VARARGS, NULL},
	{ (char *)"string_find_last_not_of", _wrap_string_find_last_not_of, METH_VARARGS, NULL},
	{ (char *)"string_substr", _wrap_string_substr, METH_VARARGS, NULL},
	{ (char *)"string_empty", _wrap_string_empty, METH_VARARGS, NULL},
	{ (char *)"string_size", _wrap_string_size, METH_VARARGS, NULL},
	{ (char *)"string_swap", _wrap_string_swap, METH_VARARGS, NULL},
	{ (char *)"string_begin", _wrap_string_begin, METH_VARARGS, NULL},
	{ (char *)"string_end", _wrap_string_end, METH_VARARGS, NULL},
	{ (char *)"string_rbegin", _wrap_string_rbegin, METH_VARARGS, NULL},
	{ (char *)"string_rend", _wrap_string_rend, METH_VARARGS, NULL},
	{ (char *)"string_get_allocator", _wrap_string_get_allocator, METH_VARARGS, NULL},
	{ (char *)"string_erase", _wrap_string_erase, METH_VARARGS, NULL},
	{ (char *)"new_string", _wrap_new_string, METH_VARARGS, NULL},
	{ (char *)"string_assign", _wrap_string_assign, METH_VARARGS, NULL},
	{ (char *)"string_resize", _wrap_string_resize, METH_VARARGS, NULL},
	{ (char *)"string_iterator", _wrap_string_iterator, METH_VARARGS, NULL},
	{ (char *)"string___nonzero__", _wrap_string___nonzero__, METH_VARARGS, NULL},
	{ (char *)"string___bool__", _wrap_string___bool__, METH_VARARGS, NULL},
	{ (char *)"string___len__", _wrap_string___len__, METH_VARARGS, NULL},
	{ (char *)"string___getslice__", _wrap_string___getslice__, METH_VARARGS, NULL},
	{ (char *)"string___setslice__", _wrap_string___setslice__, METH_VARARGS, NULL},
	{ (char *)"string___delslice__", _wrap_string___delslice__, METH_VARARGS, NULL},
	{ (char *)"string___delitem__", _wrap_string___delitem__, METH_VARARGS, NULL},
	{ (char *)"string___getitem__", _wrap_string___getitem__, METH_VARARGS, NULL},
	{ (char *)"string___setitem__", _wrap_string___setitem__, METH_VARARGS, NULL},
	{ (char *)"string_insert", _wrap_string_insert, METH_VARARGS, NULL},
	{ (char *)"string_replace", _wrap_string_replace, METH_VARARGS, NULL},
	{ (char *)"string___iadd__", _wrap_string___iadd__, METH_VARARGS, NULL},
	{ (char *)"string___add__", _wrap_string___add__, METH_VARARGS, NULL},
	{ (char *)"string___radd__", _wrap_string___radd__, METH_VARARGS, NULL},
	{ (char *)"string___str__", _wrap_string___str__, METH_VARARGS, NULL},
	{ (char *)"string___rlshift__", _wrap_string___rlshift__, METH_VARARGS, NULL},
	{ (char *)"string___eq__", _wrap_string___eq__, METH_VARARGS, NULL},
	{ (char *)"string___ne__", _wrap_string___ne__, METH_VARARGS, NULL},
	{ (char *)"string___gt__", _wrap_string___gt__, METH_VARARGS, NULL},
	{ (char *)"string___lt__", _wrap_string___lt__, METH_VARARGS, NULL},
	{ (char *)"string___ge__", _wrap_string___ge__, METH_VARARGS, NULL},
	{ (char *)"string___le__", _wrap_string___le__, METH_VARARGS, NULL},
	{ (char *)"delete_string", _wrap_delete_string, METH_VARARGS, NULL},
	{ (char *)"string_swigregister", string_swigregister, METH_VARARGS, NULL},
	{ (char *)"ios_base_register_callback", _wrap_ios_base_register_callback, METH_VARARGS, NULL},
	{ (char *)"ios_base_flags", _wrap_ios_base_flags, METH_VARARGS, NULL},
	{ (char *)"ios_base_setf", _wrap_ios_base_setf, METH_VARARGS, NULL},
	{ (char *)"ios_base_unsetf", _wrap_ios_base_unsetf, METH_VARARGS, NULL},
	{ (char *)"ios_base_precision", _wrap_ios_base_precision, METH_VARARGS, NULL},
	{ (char *)"ios_base_width", _wrap_ios_base_width, METH_VARARGS, NULL},
	{ (char *)"ios_base_sync_with_stdio", _wrap_ios_base_sync_with_stdio, METH_VARARGS, NULL},
	{ (char *)"ios_base_imbue", _wrap_ios_base_imbue, METH_VARARGS, NULL},
	{ (char *)"ios_base_getloc", _wrap_ios_base_getloc, METH_VARARGS, NULL},
	{ (char *)"ios_base_xalloc", _wrap_ios_base_xalloc, METH_VARARGS, NULL},
	{ (char *)"ios_base_iword", _wrap_ios_base_iword, METH_VARARGS, NULL},
	{ (char *)"ios_base_pword", _wrap_ios_base_pword, METH_VARARGS, NULL},
	{ (char *)"delete_ios_base", _wrap_delete_ios_base, METH_VARARGS, NULL},
	{ (char *)"ios_base_swigregister", ios_base_swigregister, METH_VARARGS, NULL},
	{ (char *)"ios_rdstate", _wrap_ios_rdstate, METH_VARARGS, NULL},
	{ (char *)"ios_clear", _wrap_ios_clear, METH_VARARGS, NULL},
	{ (char *)"ios_setstate", _wrap_ios_setstate, METH_VARARGS, NULL},
	{ (char *)"ios_good", _wrap_ios_good, METH_VARARGS, NULL},
	{ (char *)"ios_eof", _wrap_ios_eof, METH_VARARGS, NULL},
	{ (char *)"ios_fail", _wrap_ios_fail, METH_VARARGS, NULL},
	{ (char *)"ios_bad", _wrap_ios_bad, METH_VARARGS, NULL},
	{ (char *)"ios_exceptions", _wrap_ios_exceptions, METH_VARARGS, NULL},
	{ (char *)"new_ios", _wrap_new_ios, METH_VARARGS, NULL},
	{ (char *)"delete_ios", _wrap_delete_ios, METH_VARARGS, NULL},
	{ (char *)"ios_tie", _wrap_ios_tie, METH_VARARGS, NULL},
	{ (char *)"ios_rdbuf", _wrap_ios_rdbuf, METH_VARARGS, NULL},
	{ (char *)"ios_copyfmt", _wrap_ios_copyfmt, METH_VARARGS, NULL},
	{ (char *)"ios_fill", _wrap_ios_fill, METH_VARARGS, NULL},
	{ (char *)"ios_imbue", _wrap_ios_imbue, METH_VARARGS, NULL},
	{ (char *)"ios_narrow", _wrap_ios_narrow, METH_VARARGS, NULL},
	{ (char *)"ios_widen", _wrap_ios_widen, METH_VARARGS, NULL},
	{ (char *)"ios_swigregister", ios_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_streambuf", _wrap_delete_streambuf, METH_VARARGS, NULL},
	{ (char *)"streambuf_pubimbue", _wrap_streambuf_pubimbue, METH_VARARGS, NULL},
	{ (char *)"streambuf_getloc", _wrap_streambuf_getloc, METH_VARARGS, NULL},
	{ (char *)"streambuf_pubsetbuf", _wrap_streambuf_pubsetbuf, METH_VARARGS, NULL},
	{ (char *)"streambuf_pubseekoff", _wrap_streambuf_pubseekoff, METH_VARARGS, NULL},
	{ (char *)"streambuf_pubseekpos", _wrap_streambuf_pubseekpos, METH_VARARGS, NULL},
	{ (char *)"streambuf_pubsync", _wrap_streambuf_pubsync, METH_VARARGS, NULL},
	{ (char *)"streambuf_in_avail", _wrap_streambuf_in_avail, METH_VARARGS, NULL},
	{ (char *)"streambuf_snextc", _wrap_streambuf_snextc, METH_VARARGS, NULL},
	{ (char *)"streambuf_sbumpc", _wrap_streambuf_sbumpc, METH_VARARGS, NULL},
	{ (char *)"streambuf_sgetc", _wrap_streambuf_sgetc, METH_VARARGS, NULL},
	{ (char *)"streambuf_sgetn", _wrap_streambuf_sgetn, METH_VARARGS, NULL},
	{ (char *)"streambuf_sputbackc", _wrap_streambuf_sputbackc, METH_VARARGS, NULL},
	{ (char *)"streambuf_sungetc", _wrap_streambuf_sungetc, METH_VARARGS, NULL},
	{ (char *)"streambuf_sputc", _wrap_streambuf_sputc, METH_VARARGS, NULL},
	{ (char *)"streambuf_sputn", _wrap_streambuf_sputn, METH_VARARGS, NULL},
	{ (char *)"streambuf_swigregister", streambuf_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ostream", _wrap_new_ostream, METH_VARARGS, NULL},
	{ (char *)"delete_ostream", _wrap_delete_ostream, METH_VARARGS, NULL},
	{ (char *)"ostream___lshift__", _wrap_ostream___lshift__, METH_VARARGS, NULL},
	{ (char *)"ostream_put", _wrap_ostream_put, METH_VARARGS, NULL},
	{ (char *)"ostream_write", _wrap_ostream_write, METH_VARARGS, NULL},
	{ (char *)"ostream_flush", _wrap_ostream_flush, METH_VARARGS, NULL},
	{ (char *)"ostream_tellp", _wrap_ostream_tellp, METH_VARARGS, NULL},
	{ (char *)"ostream_seekp", _wrap_ostream_seekp, METH_VARARGS, NULL},
	{ (char *)"ostream_swigregister", ostream_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_istream", _wrap_new_istream, METH_VARARGS, NULL},
	{ (char *)"delete_istream", _wrap_delete_istream, METH_VARARGS, NULL},
	{ (char *)"istream___rshift__", _wrap_istream___rshift__, METH_VARARGS, NULL},
	{ (char *)"istream_gcount", _wrap_istream_gcount, METH_VARARGS, NULL},
	{ (char *)"istream_get", _wrap_istream_get, METH_VARARGS, NULL},
	{ (char *)"istream_getline", _wrap_istream_getline, METH_VARARGS, NULL},
	{ (char *)"istream_ignore", _wrap_istream_ignore, METH_VARARGS, NULL},
	{ (char *)"istream_peek", _wrap_istream_peek, METH_VARARGS, NULL},
	{ (char *)"istream_read", _wrap_istream_read, METH_VARARGS, NULL},
	{ (char *)"istream_readsome", _wrap_istream_readsome, METH_VARARGS, NULL},
	{ (char *)"istream_putback", _wrap_istream_putback, METH_VARARGS, NULL},
	{ (char *)"istream_unget", _wrap_istream_unget, METH_VARARGS, NULL},
	{ (char *)"istream_sync", _wrap_istream_sync, METH_VARARGS, NULL},
	{ (char *)"istream_tellg", _wrap_istream_tellg, METH_VARARGS, NULL},
	{ (char *)"istream_seekg", _wrap_istream_seekg, METH_VARARGS, NULL},
	{ (char *)"istream_swigregister", istream_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_iostream", _wrap_new_iostream, METH_VARARGS, NULL},
	{ (char *)"delete_iostream", _wrap_delete_iostream, METH_VARARGS, NULL},
	{ (char *)"iostream_swigregister", iostream_swigregister, METH_VARARGS, NULL},
	{ (char )"endl", _wrap_endl, METH_VARARGS, (char )"swig_ptr: endl_cb_ptr"},
	{ (char )"ends", _wrap_ends, METH_VARARGS, (char )"swig_ptr: ends_cb_ptr"},
	{ (char )"flush", _wrap_flush, METH_VARARGS, (char )"swig_ptr: flush_cb_ptr"},
	{ (char *)"new_istringstream", _wrap_new_istringstream, METH_VARARGS, NULL},
	{ (char *)"delete_istringstream", _wrap_delete_istringstream, METH_VARARGS, NULL},
	{ (char *)"istringstream_rdbuf", _wrap_istringstream_rdbuf, METH_VARARGS, NULL},
	{ (char *)"istringstream_str", _wrap_istringstream_str, METH_VARARGS, NULL},
	{ (char *)"istringstream_swigregister", istringstream_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ostringstream", _wrap_new_ostringstream, METH_VARARGS, NULL},
	{ (char *)"delete_ostringstream", _wrap_delete_ostringstream, METH_VARARGS, NULL},
	{ (char *)"ostringstream_rdbuf", _wrap_ostringstream_rdbuf, METH_VARARGS, NULL},
	{ (char *)"ostringstream_str", _wrap_ostringstream_str, METH_VARARGS, NULL},
	{ (char *)"ostringstream_swigregister", ostringstream_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_stringstream", _wrap_new_stringstream, METH_VARARGS, NULL},
	{ (char *)"delete_stringstream", _wrap_delete_stringstream, METH_VARARGS, NULL},
	{ (char *)"stringstream_rdbuf", _wrap_stringstream_rdbuf, METH_VARARGS, NULL},
	{ (char *)"stringstream_str", _wrap_stringstream_str, METH_VARARGS, NULL},
	{ (char *)"stringstream_swigregister", stringstream_swigregister, METH_VARARGS, NULL},
	{ (char *)"SCharVector_iterator", _wrap_SCharVector_iterator, METH_VARARGS, NULL},
	{ (char *)"SCharVector___nonzero__", _wrap_SCharVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"SCharVector___bool__", _wrap_SCharVector___bool__, METH_VARARGS, NULL},
	{ (char *)"SCharVector___len__", _wrap_SCharVector___len__, METH_VARARGS, NULL},
	{ (char *)"SCharVector___getslice__", _wrap_SCharVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"SCharVector___setslice__", _wrap_SCharVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"SCharVector___delslice__", _wrap_SCharVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"SCharVector___delitem__", _wrap_SCharVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"SCharVector___getitem__", _wrap_SCharVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"SCharVector___setitem__", _wrap_SCharVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"SCharVector_pop", _wrap_SCharVector_pop, METH_VARARGS, NULL},
	{ (char *)"SCharVector_append", _wrap_SCharVector_append, METH_VARARGS, NULL},
	{ (char *)"SCharVector_empty", _wrap_SCharVector_empty, METH_VARARGS, NULL},
	{ (char *)"SCharVector_size", _wrap_SCharVector_size, METH_VARARGS, NULL},
	{ (char *)"SCharVector_swap", _wrap_SCharVector_swap, METH_VARARGS, NULL},
	{ (char *)"SCharVector_begin", _wrap_SCharVector_begin, METH_VARARGS, NULL},
	{ (char *)"SCharVector_end", _wrap_SCharVector_end, METH_VARARGS, NULL},
	{ (char *)"SCharVector_rbegin", _wrap_SCharVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"SCharVector_rend", _wrap_SCharVector_rend, METH_VARARGS, NULL},
	{ (char *)"SCharVector_clear", _wrap_SCharVector_clear, METH_VARARGS, NULL},
	{ (char *)"SCharVector_get_allocator", _wrap_SCharVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"SCharVector_pop_back", _wrap_SCharVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"SCharVector_erase", _wrap_SCharVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_SCharVector", _wrap_new_SCharVector, METH_VARARGS, NULL},
	{ (char *)"SCharVector_push_back", _wrap_SCharVector_push_back, METH_VARARGS, NULL},
	{ (char *)"SCharVector_front", _wrap_SCharVector_front, METH_VARARGS, NULL},
	{ (char *)"SCharVector_back", _wrap_SCharVector_back, METH_VARARGS, NULL},
	{ (char *)"SCharVector_assign", _wrap_SCharVector_assign, METH_VARARGS, NULL},
	{ (char *)"SCharVector_resize", _wrap_SCharVector_resize, METH_VARARGS, NULL},
	{ (char *)"SCharVector_insert", _wrap_SCharVector_insert, METH_VARARGS, NULL},
	{ (char *)"SCharVector_reserve", _wrap_SCharVector_reserve, METH_VARARGS, NULL},
	{ (char *)"SCharVector_capacity", _wrap_SCharVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_SCharVector", _wrap_delete_SCharVector, METH_VARARGS, NULL},
	{ (char *)"SCharVector_swigregister", SCharVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"UCharVector_iterator", _wrap_UCharVector_iterator, METH_VARARGS, NULL},
	{ (char *)"UCharVector___nonzero__", _wrap_UCharVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"UCharVector___bool__", _wrap_UCharVector___bool__, METH_VARARGS, NULL},
	{ (char *)"UCharVector___len__", _wrap_UCharVector___len__, METH_VARARGS, NULL},
	{ (char *)"UCharVector___getslice__", _wrap_UCharVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"UCharVector___setslice__", _wrap_UCharVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"UCharVector___delslice__", _wrap_UCharVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"UCharVector___delitem__", _wrap_UCharVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"UCharVector___getitem__", _wrap_UCharVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"UCharVector___setitem__", _wrap_UCharVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"UCharVector_pop", _wrap_UCharVector_pop, METH_VARARGS, NULL},
	{ (char *)"UCharVector_append", _wrap_UCharVector_append, METH_VARARGS, NULL},
	{ (char *)"UCharVector_empty", _wrap_UCharVector_empty, METH_VARARGS, NULL},
	{ (char *)"UCharVector_size", _wrap_UCharVector_size, METH_VARARGS, NULL},
	{ (char *)"UCharVector_swap", _wrap_UCharVector_swap, METH_VARARGS, NULL},
	{ (char *)"UCharVector_begin", _wrap_UCharVector_begin, METH_VARARGS, NULL},
	{ (char *)"UCharVector_end", _wrap_UCharVector_end, METH_VARARGS, NULL},
	{ (char *)"UCharVector_rbegin", _wrap_UCharVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"UCharVector_rend", _wrap_UCharVector_rend, METH_VARARGS, NULL},
	{ (char *)"UCharVector_clear", _wrap_UCharVector_clear, METH_VARARGS, NULL},
	{ (char *)"UCharVector_get_allocator", _wrap_UCharVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"UCharVector_pop_back", _wrap_UCharVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"UCharVector_erase", _wrap_UCharVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_UCharVector", _wrap_new_UCharVector, METH_VARARGS, NULL},
	{ (char *)"UCharVector_push_back", _wrap_UCharVector_push_back, METH_VARARGS, NULL},
	{ (char *)"UCharVector_front", _wrap_UCharVector_front, METH_VARARGS, NULL},
	{ (char *)"UCharVector_back", _wrap_UCharVector_back, METH_VARARGS, NULL},
	{ (char *)"UCharVector_assign", _wrap_UCharVector_assign, METH_VARARGS, NULL},
	{ (char *)"UCharVector_resize", _wrap_UCharVector_resize, METH_VARARGS, NULL},
	{ (char *)"UCharVector_insert", _wrap_UCharVector_insert, METH_VARARGS, NULL},
	{ (char *)"UCharVector_reserve", _wrap_UCharVector_reserve, METH_VARARGS, NULL},
	{ (char *)"UCharVector_capacity", _wrap_UCharVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_UCharVector", _wrap_delete_UCharVector, METH_VARARGS, NULL},
	{ (char *)"UCharVector_swigregister", UCharVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"ShortVector_iterator", _wrap_ShortVector_iterator, METH_VARARGS, NULL},
	{ (char *)"ShortVector___nonzero__", _wrap_ShortVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"ShortVector___bool__", _wrap_ShortVector___bool__, METH_VARARGS, NULL},
	{ (char *)"ShortVector___len__", _wrap_ShortVector___len__, METH_VARARGS, NULL},
	{ (char *)"ShortVector___getslice__", _wrap_ShortVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"ShortVector___setslice__", _wrap_ShortVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"ShortVector___delslice__", _wrap_ShortVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"ShortVector___delitem__", _wrap_ShortVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"ShortVector___getitem__", _wrap_ShortVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"ShortVector___setitem__", _wrap_ShortVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"ShortVector_pop", _wrap_ShortVector_pop, METH_VARARGS, NULL},
	{ (char *)"ShortVector_append", _wrap_ShortVector_append, METH_VARARGS, NULL},
	{ (char *)"ShortVector_empty", _wrap_ShortVector_empty, METH_VARARGS, NULL},
	{ (char *)"ShortVector_size", _wrap_ShortVector_size, METH_VARARGS, NULL},
	{ (char *)"ShortVector_swap", _wrap_ShortVector_swap, METH_VARARGS, NULL},
	{ (char *)"ShortVector_begin", _wrap_ShortVector_begin, METH_VARARGS, NULL},
	{ (char *)"ShortVector_end", _wrap_ShortVector_end, METH_VARARGS, NULL},
	{ (char *)"ShortVector_rbegin", _wrap_ShortVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"ShortVector_rend", _wrap_ShortVector_rend, METH_VARARGS, NULL},
	{ (char *)"ShortVector_clear", _wrap_ShortVector_clear, METH_VARARGS, NULL},
	{ (char *)"ShortVector_get_allocator", _wrap_ShortVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"ShortVector_pop_back", _wrap_ShortVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"ShortVector_erase", _wrap_ShortVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_ShortVector", _wrap_new_ShortVector, METH_VARARGS, NULL},
	{ (char *)"ShortVector_push_back", _wrap_ShortVector_push_back, METH_VARARGS, NULL},
	{ (char *)"ShortVector_front", _wrap_ShortVector_front, METH_VARARGS, NULL},
	{ (char *)"ShortVector_back", _wrap_ShortVector_back, METH_VARARGS, NULL},
	{ (char *)"ShortVector_assign", _wrap_ShortVector_assign, METH_VARARGS, NULL},
	{ (char *)"ShortVector_resize", _wrap_ShortVector_resize, METH_VARARGS, NULL},
	{ (char *)"ShortVector_insert", _wrap_ShortVector_insert, METH_VARARGS, NULL},
	{ (char *)"ShortVector_reserve", _wrap_ShortVector_reserve, METH_VARARGS, NULL},
	{ (char *)"ShortVector_capacity", _wrap_ShortVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_ShortVector", _wrap_delete_ShortVector, METH_VARARGS, NULL},
	{ (char *)"ShortVector_swigregister", ShortVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"UShortVector_iterator", _wrap_UShortVector_iterator, METH_VARARGS, NULL},
	{ (char *)"UShortVector___nonzero__", _wrap_UShortVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"UShortVector___bool__", _wrap_UShortVector___bool__, METH_VARARGS, NULL},
	{ (char *)"UShortVector___len__", _wrap_UShortVector___len__, METH_VARARGS, NULL},
	{ (char *)"UShortVector___getslice__", _wrap_UShortVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"UShortVector___setslice__", _wrap_UShortVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"UShortVector___delslice__", _wrap_UShortVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"UShortVector___delitem__", _wrap_UShortVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"UShortVector___getitem__", _wrap_UShortVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"UShortVector___setitem__", _wrap_UShortVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"UShortVector_pop", _wrap_UShortVector_pop, METH_VARARGS, NULL},
	{ (char *)"UShortVector_append", _wrap_UShortVector_append, METH_VARARGS, NULL},
	{ (char *)"UShortVector_empty", _wrap_UShortVector_empty, METH_VARARGS, NULL},
	{ (char *)"UShortVector_size", _wrap_UShortVector_size, METH_VARARGS, NULL},
	{ (char *)"UShortVector_swap", _wrap_UShortVector_swap, METH_VARARGS, NULL},
	{ (char *)"UShortVector_begin", _wrap_UShortVector_begin, METH_VARARGS, NULL},
	{ (char *)"UShortVector_end", _wrap_UShortVector_end, METH_VARARGS, NULL},
	{ (char *)"UShortVector_rbegin", _wrap_UShortVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"UShortVector_rend", _wrap_UShortVector_rend, METH_VARARGS, NULL},
	{ (char *)"UShortVector_clear", _wrap_UShortVector_clear, METH_VARARGS, NULL},
	{ (char *)"UShortVector_get_allocator", _wrap_UShortVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"UShortVector_pop_back", _wrap_UShortVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"UShortVector_erase", _wrap_UShortVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_UShortVector", _wrap_new_UShortVector, METH_VARARGS, NULL},
	{ (char *)"UShortVector_push_back", _wrap_UShortVector_push_back, METH_VARARGS, NULL},
	{ (char *)"UShortVector_front", _wrap_UShortVector_front, METH_VARARGS, NULL},
	{ (char *)"UShortVector_back", _wrap_UShortVector_back, METH_VARARGS, NULL},
	{ (char *)"UShortVector_assign", _wrap_UShortVector_assign, METH_VARARGS, NULL},
	{ (char *)"UShortVector_resize", _wrap_UShortVector_resize, METH_VARARGS, NULL},
	{ (char *)"UShortVector_insert", _wrap_UShortVector_insert, METH_VARARGS, NULL},
	{ (char *)"UShortVector_reserve", _wrap_UShortVector_reserve, METH_VARARGS, NULL},
	{ (char *)"UShortVector_capacity", _wrap_UShortVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_UShortVector", _wrap_delete_UShortVector, METH_VARARGS, NULL},
	{ (char *)"UShortVector_swigregister", UShortVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"LongVector_iterator", _wrap_LongVector_iterator, METH_VARARGS, NULL},
	{ (char *)"LongVector___nonzero__", _wrap_LongVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"LongVector___bool__", _wrap_LongVector___bool__, METH_VARARGS, NULL},
	{ (char *)"LongVector___len__", _wrap_LongVector___len__, METH_VARARGS, NULL},
	{ (char *)"LongVector___getslice__", _wrap_LongVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"LongVector___setslice__", _wrap_LongVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"LongVector___delslice__", _wrap_LongVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"LongVector___delitem__", _wrap_LongVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"LongVector___getitem__", _wrap_LongVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"LongVector___setitem__", _wrap_LongVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"LongVector_pop", _wrap_LongVector_pop, METH_VARARGS, NULL},
	{ (char *)"LongVector_append", _wrap_LongVector_append, METH_VARARGS, NULL},
	{ (char *)"LongVector_empty", _wrap_LongVector_empty, METH_VARARGS, NULL},
	{ (char *)"LongVector_size", _wrap_LongVector_size, METH_VARARGS, NULL},
	{ (char *)"LongVector_swap", _wrap_LongVector_swap, METH_VARARGS, NULL},
	{ (char *)"LongVector_begin", _wrap_LongVector_begin, METH_VARARGS, NULL},
	{ (char *)"LongVector_end", _wrap_LongVector_end, METH_VARARGS, NULL},
	{ (char *)"LongVector_rbegin", _wrap_LongVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"LongVector_rend", _wrap_LongVector_rend, METH_VARARGS, NULL},
	{ (char *)"LongVector_clear", _wrap_LongVector_clear, METH_VARARGS, NULL},
	{ (char *)"LongVector_get_allocator", _wrap_LongVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"LongVector_pop_back", _wrap_LongVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"LongVector_erase", _wrap_LongVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_LongVector", _wrap_new_LongVector, METH_VARARGS, NULL},
	{ (char *)"LongVector_push_back", _wrap_LongVector_push_back, METH_VARARGS, NULL},
	{ (char *)"LongVector_front", _wrap_LongVector_front, METH_VARARGS, NULL},
	{ (char *)"LongVector_back", _wrap_LongVector_back, METH_VARARGS, NULL},
	{ (char *)"LongVector_assign", _wrap_LongVector_assign, METH_VARARGS, NULL},
	{ (char *)"LongVector_resize", _wrap_LongVector_resize, METH_VARARGS, NULL},
	{ (char *)"LongVector_insert", _wrap_LongVector_insert, METH_VARARGS, NULL},
	{ (char *)"LongVector_reserve", _wrap_LongVector_reserve, METH_VARARGS, NULL},
	{ (char *)"LongVector_capacity", _wrap_LongVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_LongVector", _wrap_delete_LongVector, METH_VARARGS, NULL},
	{ (char *)"LongVector_swigregister", LongVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"ULongVector_iterator", _wrap_ULongVector_iterator, METH_VARARGS, NULL},
	{ (char *)"ULongVector___nonzero__", _wrap_ULongVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"ULongVector___bool__", _wrap_ULongVector___bool__, METH_VARARGS, NULL},
	{ (char *)"ULongVector___len__", _wrap_ULongVector___len__, METH_VARARGS, NULL},
	{ (char *)"ULongVector___getslice__", _wrap_ULongVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"ULongVector___setslice__", _wrap_ULongVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"ULongVector___delslice__", _wrap_ULongVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"ULongVector___delitem__", _wrap_ULongVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"ULongVector___getitem__", _wrap_ULongVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"ULongVector___setitem__", _wrap_ULongVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"ULongVector_pop", _wrap_ULongVector_pop, METH_VARARGS, NULL},
	{ (char *)"ULongVector_append", _wrap_ULongVector_append, METH_VARARGS, NULL},
	{ (char *)"ULongVector_empty", _wrap_ULongVector_empty, METH_VARARGS, NULL},
	{ (char *)"ULongVector_size", _wrap_ULongVector_size, METH_VARARGS, NULL},
	{ (char *)"ULongVector_swap", _wrap_ULongVector_swap, METH_VARARGS, NULL},
	{ (char *)"ULongVector_begin", _wrap_ULongVector_begin, METH_VARARGS, NULL},
	{ (char *)"ULongVector_end", _wrap_ULongVector_end, METH_VARARGS, NULL},
	{ (char *)"ULongVector_rbegin", _wrap_ULongVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"ULongVector_rend", _wrap_ULongVector_rend, METH_VARARGS, NULL},
	{ (char *)"ULongVector_clear", _wrap_ULongVector_clear, METH_VARARGS, NULL},
	{ (char *)"ULongVector_get_allocator", _wrap_ULongVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"ULongVector_pop_back", _wrap_ULongVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"ULongVector_erase", _wrap_ULongVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_ULongVector", _wrap_new_ULongVector, METH_VARARGS, NULL},
	{ (char *)"ULongVector_push_back", _wrap_ULongVector_push_back, METH_VARARGS, NULL},
	{ (char *)"ULongVector_front", _wrap_ULongVector_front, METH_VARARGS, NULL},
	{ (char *)"ULongVector_back", _wrap_ULongVector_back, METH_VARARGS, NULL},
	{ (char *)"ULongVector_assign", _wrap_ULongVector_assign, METH_VARARGS, NULL},
	{ (char *)"ULongVector_resize", _wrap_ULongVector_resize, METH_VARARGS, NULL},
	{ (char *)"ULongVector_insert", _wrap_ULongVector_insert, METH_VARARGS, NULL},
	{ (char *)"ULongVector_reserve", _wrap_ULongVector_reserve, METH_VARARGS, NULL},
	{ (char *)"ULongVector_capacity", _wrap_ULongVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_ULongVector", _wrap_delete_ULongVector, METH_VARARGS, NULL},
	{ (char *)"ULongVector_swigregister", ULongVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"IntVector_iterator", _wrap_IntVector_iterator, METH_VARARGS, NULL},
	{ (char *)"IntVector___nonzero__", _wrap_IntVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"IntVector___bool__", _wrap_IntVector___bool__, METH_VARARGS, NULL},
	{ (char *)"IntVector___len__", _wrap_IntVector___len__, METH_VARARGS, NULL},
	{ (char *)"IntVector___getslice__", _wrap_IntVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"IntVector___setslice__", _wrap_IntVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"IntVector___delslice__", _wrap_IntVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"IntVector___delitem__", _wrap_IntVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"IntVector___getitem__", _wrap_IntVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"IntVector___setitem__", _wrap_IntVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"IntVector_pop", _wrap_IntVector_pop, METH_VARARGS, NULL},
	{ (char *)"IntVector_append", _wrap_IntVector_append, METH_VARARGS, NULL},
	{ (char *)"IntVector_empty", _wrap_IntVector_empty, METH_VARARGS, NULL},
	{ (char *)"IntVector_size", _wrap_IntVector_size, METH_VARARGS, NULL},
	{ (char *)"IntVector_swap", _wrap_IntVector_swap, METH_VARARGS, NULL},
	{ (char *)"IntVector_begin", _wrap_IntVector_begin, METH_VARARGS, NULL},
	{ (char *)"IntVector_end", _wrap_IntVector_end, METH_VARARGS, NULL},
	{ (char *)"IntVector_rbegin", _wrap_IntVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"IntVector_rend", _wrap_IntVector_rend, METH_VARARGS, NULL},
	{ (char *)"IntVector_clear", _wrap_IntVector_clear, METH_VARARGS, NULL},
	{ (char *)"IntVector_get_allocator", _wrap_IntVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"IntVector_pop_back", _wrap_IntVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"IntVector_erase", _wrap_IntVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_IntVector", _wrap_new_IntVector, METH_VARARGS, NULL},
	{ (char *)"IntVector_push_back", _wrap_IntVector_push_back, METH_VARARGS, NULL},
	{ (char *)"IntVector_front", _wrap_IntVector_front, METH_VARARGS, NULL},
	{ (char *)"IntVector_back", _wrap_IntVector_back, METH_VARARGS, NULL},
	{ (char *)"IntVector_assign", _wrap_IntVector_assign, METH_VARARGS, NULL},
	{ (char *)"IntVector_resize", _wrap_IntVector_resize, METH_VARARGS, NULL},
	{ (char *)"IntVector_insert", _wrap_IntVector_insert, METH_VARARGS, NULL},
	{ (char *)"IntVector_reserve", _wrap_IntVector_reserve, METH_VARARGS, NULL},
	{ (char *)"IntVector_capacity", _wrap_IntVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_IntVector", _wrap_delete_IntVector, METH_VARARGS, NULL},
	{ (char *)"IntVector_swigregister", IntVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"LLongVector_iterator", _wrap_LLongVector_iterator, METH_VARARGS, NULL},
	{ (char *)"LLongVector___nonzero__", _wrap_LLongVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"LLongVector___bool__", _wrap_LLongVector___bool__, METH_VARARGS, NULL},
	{ (char *)"LLongVector___len__", _wrap_LLongVector___len__, METH_VARARGS, NULL},
	{ (char *)"LLongVector___getslice__", _wrap_LLongVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"LLongVector___setslice__", _wrap_LLongVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"LLongVector___delslice__", _wrap_LLongVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"LLongVector___delitem__", _wrap_LLongVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"LLongVector___getitem__", _wrap_LLongVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"LLongVector___setitem__", _wrap_LLongVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"LLongVector_pop", _wrap_LLongVector_pop, METH_VARARGS, NULL},
	{ (char *)"LLongVector_append", _wrap_LLongVector_append, METH_VARARGS, NULL},
	{ (char *)"LLongVector_empty", _wrap_LLongVector_empty, METH_VARARGS, NULL},
	{ (char *)"LLongVector_size", _wrap_LLongVector_size, METH_VARARGS, NULL},
	{ (char *)"LLongVector_swap", _wrap_LLongVector_swap, METH_VARARGS, NULL},
	{ (char *)"LLongVector_begin", _wrap_LLongVector_begin, METH_VARARGS, NULL},
	{ (char *)"LLongVector_end", _wrap_LLongVector_end, METH_VARARGS, NULL},
	{ (char *)"LLongVector_rbegin", _wrap_LLongVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"LLongVector_rend", _wrap_LLongVector_rend, METH_VARARGS, NULL},
	{ (char *)"LLongVector_clear", _wrap_LLongVector_clear, METH_VARARGS, NULL},
	{ (char *)"LLongVector_get_allocator", _wrap_LLongVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"LLongVector_pop_back", _wrap_LLongVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"LLongVector_erase", _wrap_LLongVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_LLongVector", _wrap_new_LLongVector, METH_VARARGS, NULL},
	{ (char *)"LLongVector_push_back", _wrap_LLongVector_push_back, METH_VARARGS, NULL},
	{ (char *)"LLongVector_front", _wrap_LLongVector_front, METH_VARARGS, NULL},
	{ (char *)"LLongVector_back", _wrap_LLongVector_back, METH_VARARGS, NULL},
	{ (char *)"LLongVector_assign", _wrap_LLongVector_assign, METH_VARARGS, NULL},
	{ (char *)"LLongVector_resize", _wrap_LLongVector_resize, METH_VARARGS, NULL},
	{ (char *)"LLongVector_insert", _wrap_LLongVector_insert, METH_VARARGS, NULL},
	{ (char *)"LLongVector_reserve", _wrap_LLongVector_reserve, METH_VARARGS, NULL},
	{ (char *)"LLongVector_capacity", _wrap_LLongVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_LLongVector", _wrap_delete_LLongVector, METH_VARARGS, NULL},
	{ (char *)"LLongVector_swigregister", LLongVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"UIntVector_iterator", _wrap_UIntVector_iterator, METH_VARARGS, NULL},
	{ (char *)"UIntVector___nonzero__", _wrap_UIntVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"UIntVector___bool__", _wrap_UIntVector___bool__, METH_VARARGS, NULL},
	{ (char *)"UIntVector___len__", _wrap_UIntVector___len__, METH_VARARGS, NULL},
	{ (char *)"UIntVector___getslice__", _wrap_UIntVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"UIntVector___setslice__", _wrap_UIntVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"UIntVector___delslice__", _wrap_UIntVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"UIntVector___delitem__", _wrap_UIntVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"UIntVector___getitem__", _wrap_UIntVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"UIntVector___setitem__", _wrap_UIntVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"UIntVector_pop", _wrap_UIntVector_pop, METH_VARARGS, NULL},
	{ (char *)"UIntVector_append", _wrap_UIntVector_append, METH_VARARGS, NULL},
	{ (char *)"UIntVector_empty", _wrap_UIntVector_empty, METH_VARARGS, NULL},
	{ (char *)"UIntVector_size", _wrap_UIntVector_size, METH_VARARGS, NULL},
	{ (char *)"UIntVector_swap", _wrap_UIntVector_swap, METH_VARARGS, NULL},
	{ (char *)"UIntVector_begin", _wrap_UIntVector_begin, METH_VARARGS, NULL},
	{ (char *)"UIntVector_end", _wrap_UIntVector_end, METH_VARARGS, NULL},
	{ (char *)"UIntVector_rbegin", _wrap_UIntVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"UIntVector_rend", _wrap_UIntVector_rend, METH_VARARGS, NULL},
	{ (char *)"UIntVector_clear", _wrap_UIntVector_clear, METH_VARARGS, NULL},
	{ (char *)"UIntVector_get_allocator", _wrap_UIntVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"UIntVector_pop_back", _wrap_UIntVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"UIntVector_erase", _wrap_UIntVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_UIntVector", _wrap_new_UIntVector, METH_VARARGS, NULL},
	{ (char *)"UIntVector_push_back", _wrap_UIntVector_push_back, METH_VARARGS, NULL},
	{ (char *)"UIntVector_front", _wrap_UIntVector_front, METH_VARARGS, NULL},
	{ (char *)"UIntVector_back", _wrap_UIntVector_back, METH_VARARGS, NULL},
	{ (char *)"UIntVector_assign", _wrap_UIntVector_assign, METH_VARARGS, NULL},
	{ (char *)"UIntVector_resize", _wrap_UIntVector_resize, METH_VARARGS, NULL},
	{ (char *)"UIntVector_insert", _wrap_UIntVector_insert, METH_VARARGS, NULL},
	{ (char *)"UIntVector_reserve", _wrap_UIntVector_reserve, METH_VARARGS, NULL},
	{ (char *)"UIntVector_capacity", _wrap_UIntVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_UIntVector", _wrap_delete_UIntVector, METH_VARARGS, NULL},
	{ (char *)"UIntVector_swigregister", UIntVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_iterator", _wrap_ULLongVector_iterator, METH_VARARGS, NULL},
	{ (char *)"ULLongVector___nonzero__", _wrap_ULLongVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"ULLongVector___bool__", _wrap_ULLongVector___bool__, METH_VARARGS, NULL},
	{ (char *)"ULLongVector___len__", _wrap_ULLongVector___len__, METH_VARARGS, NULL},
	{ (char *)"ULLongVector___getslice__", _wrap_ULLongVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"ULLongVector___setslice__", _wrap_ULLongVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"ULLongVector___delslice__", _wrap_ULLongVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"ULLongVector___delitem__", _wrap_ULLongVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"ULLongVector___getitem__", _wrap_ULLongVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"ULLongVector___setitem__", _wrap_ULLongVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_pop", _wrap_ULLongVector_pop, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_append", _wrap_ULLongVector_append, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_empty", _wrap_ULLongVector_empty, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_size", _wrap_ULLongVector_size, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_swap", _wrap_ULLongVector_swap, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_begin", _wrap_ULLongVector_begin, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_end", _wrap_ULLongVector_end, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_rbegin", _wrap_ULLongVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_rend", _wrap_ULLongVector_rend, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_clear", _wrap_ULLongVector_clear, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_get_allocator", _wrap_ULLongVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_pop_back", _wrap_ULLongVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_erase", _wrap_ULLongVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_ULLongVector", _wrap_new_ULLongVector, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_push_back", _wrap_ULLongVector_push_back, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_front", _wrap_ULLongVector_front, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_back", _wrap_ULLongVector_back, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_assign", _wrap_ULLongVector_assign, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_resize", _wrap_ULLongVector_resize, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_insert", _wrap_ULLongVector_insert, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_reserve", _wrap_ULLongVector_reserve, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_capacity", _wrap_ULLongVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_ULLongVector", _wrap_delete_ULLongVector, METH_VARARGS, NULL},
	{ (char *)"ULLongVector_swigregister", ULLongVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"FloatVector_iterator", _wrap_FloatVector_iterator, METH_VARARGS, NULL},
	{ (char *)"FloatVector___nonzero__", _wrap_FloatVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"FloatVector___bool__", _wrap_FloatVector___bool__, METH_VARARGS, NULL},
	{ (char *)"FloatVector___len__", _wrap_FloatVector___len__, METH_VARARGS, NULL},
	{ (char *)"FloatVector___getslice__", _wrap_FloatVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"FloatVector___setslice__", _wrap_FloatVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"FloatVector___delslice__", _wrap_FloatVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"FloatVector___delitem__", _wrap_FloatVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"FloatVector___getitem__", _wrap_FloatVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"FloatVector___setitem__", _wrap_FloatVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"FloatVector_pop", _wrap_FloatVector_pop, METH_VARARGS, NULL},
	{ (char *)"FloatVector_append", _wrap_FloatVector_append, METH_VARARGS, NULL},
	{ (char *)"FloatVector_empty", _wrap_FloatVector_empty, METH_VARARGS, NULL},
	{ (char *)"FloatVector_size", _wrap_FloatVector_size, METH_VARARGS, NULL},
	{ (char *)"FloatVector_swap", _wrap_FloatVector_swap, METH_VARARGS, NULL},
	{ (char *)"FloatVector_begin", _wrap_FloatVector_begin, METH_VARARGS, NULL},
	{ (char *)"FloatVector_end", _wrap_FloatVector_end, METH_VARARGS, NULL},
	{ (char *)"FloatVector_rbegin", _wrap_FloatVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"FloatVector_rend", _wrap_FloatVector_rend, METH_VARARGS, NULL},
	{ (char *)"FloatVector_clear", _wrap_FloatVector_clear, METH_VARARGS, NULL},
	{ (char *)"FloatVector_get_allocator", _wrap_FloatVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"FloatVector_pop_back", _wrap_FloatVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"FloatVector_erase", _wrap_FloatVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_FloatVector", _wrap_new_FloatVector, METH_VARARGS, NULL},
	{ (char *)"FloatVector_push_back", _wrap_FloatVector_push_back, METH_VARARGS, NULL},
	{ (char *)"FloatVector_front", _wrap_FloatVector_front, METH_VARARGS, NULL},
	{ (char *)"FloatVector_back", _wrap_FloatVector_back, METH_VARARGS, NULL},
	{ (char *)"FloatVector_assign", _wrap_FloatVector_assign, METH_VARARGS, NULL},
	{ (char *)"FloatVector_resize", _wrap_FloatVector_resize, METH_VARARGS, NULL},
	{ (char *)"FloatVector_insert", _wrap_FloatVector_insert, METH_VARARGS, NULL},
	{ (char *)"FloatVector_reserve", _wrap_FloatVector_reserve, METH_VARARGS, NULL},
	{ (char *)"FloatVector_capacity", _wrap_FloatVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_FloatVector", _wrap_delete_FloatVector, METH_VARARGS, NULL},
	{ (char *)"FloatVector_swigregister", FloatVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_iterator", _wrap_DoubleVector_iterator, METH_VARARGS, NULL},
	{ (char *)"DoubleVector___nonzero__", _wrap_DoubleVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"DoubleVector___bool__", _wrap_DoubleVector___bool__, METH_VARARGS, NULL},
	{ (char *)"DoubleVector___len__", _wrap_DoubleVector___len__, METH_VARARGS, NULL},
	{ (char *)"DoubleVector___getslice__", _wrap_DoubleVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"DoubleVector___setslice__", _wrap_DoubleVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"DoubleVector___delslice__", _wrap_DoubleVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"DoubleVector___delitem__", _wrap_DoubleVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"DoubleVector___getitem__", _wrap_DoubleVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"DoubleVector___setitem__", _wrap_DoubleVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_pop", _wrap_DoubleVector_pop, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_append", _wrap_DoubleVector_append, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_empty", _wrap_DoubleVector_empty, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_size", _wrap_DoubleVector_size, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_swap", _wrap_DoubleVector_swap, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_begin", _wrap_DoubleVector_begin, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_end", _wrap_DoubleVector_end, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_rbegin", _wrap_DoubleVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_rend", _wrap_DoubleVector_rend, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_clear", _wrap_DoubleVector_clear, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_get_allocator", _wrap_DoubleVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_pop_back", _wrap_DoubleVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_erase", _wrap_DoubleVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_DoubleVector", _wrap_new_DoubleVector, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_push_back", _wrap_DoubleVector_push_back, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_front", _wrap_DoubleVector_front, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_back", _wrap_DoubleVector_back, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_assign", _wrap_DoubleVector_assign, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_resize", _wrap_DoubleVector_resize, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_insert", _wrap_DoubleVector_insert, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_reserve", _wrap_DoubleVector_reserve, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_capacity", _wrap_DoubleVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleVector", _wrap_delete_DoubleVector, METH_VARARGS, NULL},
	{ (char *)"DoubleVector_swigregister", DoubleVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_iterator", _wrap_LDoubleVector_iterator, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector___nonzero__", _wrap_LDoubleVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector___bool__", _wrap_LDoubleVector___bool__, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector___len__", _wrap_LDoubleVector___len__, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector___getslice__", _wrap_LDoubleVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector___setslice__", _wrap_LDoubleVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector___delslice__", _wrap_LDoubleVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector___delitem__", _wrap_LDoubleVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector___getitem__", _wrap_LDoubleVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector___setitem__", _wrap_LDoubleVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_pop", _wrap_LDoubleVector_pop, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_append", _wrap_LDoubleVector_append, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_empty", _wrap_LDoubleVector_empty, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_size", _wrap_LDoubleVector_size, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_swap", _wrap_LDoubleVector_swap, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_begin", _wrap_LDoubleVector_begin, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_end", _wrap_LDoubleVector_end, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_rbegin", _wrap_LDoubleVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_rend", _wrap_LDoubleVector_rend, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_clear", _wrap_LDoubleVector_clear, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_get_allocator", _wrap_LDoubleVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_pop_back", _wrap_LDoubleVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_erase", _wrap_LDoubleVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_LDoubleVector", _wrap_new_LDoubleVector, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_push_back", _wrap_LDoubleVector_push_back, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_front", _wrap_LDoubleVector_front, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_back", _wrap_LDoubleVector_back, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_assign", _wrap_LDoubleVector_assign, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_resize", _wrap_LDoubleVector_resize, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_insert", _wrap_LDoubleVector_insert, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_reserve", _wrap_LDoubleVector_reserve, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_capacity", _wrap_LDoubleVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_LDoubleVector", _wrap_delete_LDoubleVector, METH_VARARGS, NULL},
	{ (char *)"LDoubleVector_swigregister", LDoubleVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_iterator", _wrap_CFloatVector_iterator, METH_VARARGS, NULL},
	{ (char *)"CFloatVector___nonzero__", _wrap_CFloatVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"CFloatVector___bool__", _wrap_CFloatVector___bool__, METH_VARARGS, NULL},
	{ (char *)"CFloatVector___len__", _wrap_CFloatVector___len__, METH_VARARGS, NULL},
	{ (char *)"CFloatVector___getslice__", _wrap_CFloatVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"CFloatVector___setslice__", _wrap_CFloatVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"CFloatVector___delslice__", _wrap_CFloatVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"CFloatVector___delitem__", _wrap_CFloatVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"CFloatVector___getitem__", _wrap_CFloatVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"CFloatVector___setitem__", _wrap_CFloatVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_pop", _wrap_CFloatVector_pop, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_append", _wrap_CFloatVector_append, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_empty", _wrap_CFloatVector_empty, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_size", _wrap_CFloatVector_size, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_swap", _wrap_CFloatVector_swap, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_begin", _wrap_CFloatVector_begin, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_end", _wrap_CFloatVector_end, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_rbegin", _wrap_CFloatVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_rend", _wrap_CFloatVector_rend, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_clear", _wrap_CFloatVector_clear, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_get_allocator", _wrap_CFloatVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_pop_back", _wrap_CFloatVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_erase", _wrap_CFloatVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_CFloatVector", _wrap_new_CFloatVector, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_push_back", _wrap_CFloatVector_push_back, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_front", _wrap_CFloatVector_front, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_back", _wrap_CFloatVector_back, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_assign", _wrap_CFloatVector_assign, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_resize", _wrap_CFloatVector_resize, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_insert", _wrap_CFloatVector_insert, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_reserve", _wrap_CFloatVector_reserve, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_capacity", _wrap_CFloatVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_CFloatVector", _wrap_delete_CFloatVector, METH_VARARGS, NULL},
	{ (char *)"CFloatVector_swigregister", CFloatVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_iterator", _wrap_CDoubleVector_iterator, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector___nonzero__", _wrap_CDoubleVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector___bool__", _wrap_CDoubleVector___bool__, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector___len__", _wrap_CDoubleVector___len__, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector___getslice__", _wrap_CDoubleVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector___setslice__", _wrap_CDoubleVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector___delslice__", _wrap_CDoubleVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector___delitem__", _wrap_CDoubleVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector___getitem__", _wrap_CDoubleVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector___setitem__", _wrap_CDoubleVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_pop", _wrap_CDoubleVector_pop, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_append", _wrap_CDoubleVector_append, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_empty", _wrap_CDoubleVector_empty, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_size", _wrap_CDoubleVector_size, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_swap", _wrap_CDoubleVector_swap, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_begin", _wrap_CDoubleVector_begin, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_end", _wrap_CDoubleVector_end, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_rbegin", _wrap_CDoubleVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_rend", _wrap_CDoubleVector_rend, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_clear", _wrap_CDoubleVector_clear, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_get_allocator", _wrap_CDoubleVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_pop_back", _wrap_CDoubleVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_erase", _wrap_CDoubleVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_CDoubleVector", _wrap_new_CDoubleVector, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_push_back", _wrap_CDoubleVector_push_back, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_front", _wrap_CDoubleVector_front, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_back", _wrap_CDoubleVector_back, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_assign", _wrap_CDoubleVector_assign, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_resize", _wrap_CDoubleVector_resize, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_insert", _wrap_CDoubleVector_insert, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_reserve", _wrap_CDoubleVector_reserve, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_capacity", _wrap_CDoubleVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_CDoubleVector", _wrap_delete_CDoubleVector, METH_VARARGS, NULL},
	{ (char *)"CDoubleVector_swigregister", CDoubleVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_iterator", _wrap_CLDoubleVector_iterator, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector___nonzero__", _wrap_CLDoubleVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector___bool__", _wrap_CLDoubleVector___bool__, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector___len__", _wrap_CLDoubleVector___len__, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector___getslice__", _wrap_CLDoubleVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector___setslice__", _wrap_CLDoubleVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector___delslice__", _wrap_CLDoubleVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector___delitem__", _wrap_CLDoubleVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector___getitem__", _wrap_CLDoubleVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector___setitem__", _wrap_CLDoubleVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_pop", _wrap_CLDoubleVector_pop, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_append", _wrap_CLDoubleVector_append, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_empty", _wrap_CLDoubleVector_empty, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_size", _wrap_CLDoubleVector_size, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_swap", _wrap_CLDoubleVector_swap, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_begin", _wrap_CLDoubleVector_begin, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_end", _wrap_CLDoubleVector_end, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_rbegin", _wrap_CLDoubleVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_rend", _wrap_CLDoubleVector_rend, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_clear", _wrap_CLDoubleVector_clear, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_get_allocator", _wrap_CLDoubleVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_pop_back", _wrap_CLDoubleVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_erase", _wrap_CLDoubleVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_CLDoubleVector", _wrap_new_CLDoubleVector, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_push_back", _wrap_CLDoubleVector_push_back, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_front", _wrap_CLDoubleVector_front, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_back", _wrap_CLDoubleVector_back, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_assign", _wrap_CLDoubleVector_assign, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_resize", _wrap_CLDoubleVector_resize, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_insert", _wrap_CLDoubleVector_insert, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_reserve", _wrap_CLDoubleVector_reserve, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_capacity", _wrap_CLDoubleVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_CLDoubleVector", _wrap_delete_CLDoubleVector, METH_VARARGS, NULL},
	{ (char *)"CLDoubleVector_swigregister", CLDoubleVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"StringVector_iterator", _wrap_StringVector_iterator, METH_VARARGS, NULL},
	{ (char *)"StringVector___nonzero__", _wrap_StringVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"StringVector___bool__", _wrap_StringVector___bool__, METH_VARARGS, NULL},
	{ (char *)"StringVector___len__", _wrap_StringVector___len__, METH_VARARGS, NULL},
	{ (char *)"StringVector___getslice__", _wrap_StringVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"StringVector___setslice__", _wrap_StringVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"StringVector___delslice__", _wrap_StringVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"StringVector___delitem__", _wrap_StringVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"StringVector___getitem__", _wrap_StringVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"StringVector___setitem__", _wrap_StringVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"StringVector_pop", _wrap_StringVector_pop, METH_VARARGS, NULL},
	{ (char *)"StringVector_append", _wrap_StringVector_append, METH_VARARGS, NULL},
	{ (char *)"StringVector_empty", _wrap_StringVector_empty, METH_VARARGS, NULL},
	{ (char *)"StringVector_size", _wrap_StringVector_size, METH_VARARGS, NULL},
	{ (char *)"StringVector_swap", _wrap_StringVector_swap, METH_VARARGS, NULL},
	{ (char *)"StringVector_begin", _wrap_StringVector_begin, METH_VARARGS, NULL},
	{ (char *)"StringVector_end", _wrap_StringVector_end, METH_VARARGS, NULL},
	{ (char *)"StringVector_rbegin", _wrap_StringVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"StringVector_rend", _wrap_StringVector_rend, METH_VARARGS, NULL},
	{ (char *)"StringVector_clear", _wrap_StringVector_clear, METH_VARARGS, NULL},
	{ (char *)"StringVector_get_allocator", _wrap_StringVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"StringVector_pop_back", _wrap_StringVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"StringVector_erase", _wrap_StringVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_StringVector", _wrap_new_StringVector, METH_VARARGS, NULL},
	{ (char *)"StringVector_push_back", _wrap_StringVector_push_back, METH_VARARGS, NULL},
	{ (char *)"StringVector_front", _wrap_StringVector_front, METH_VARARGS, NULL},
	{ (char *)"StringVector_back", _wrap_StringVector_back, METH_VARARGS, NULL},
	{ (char *)"StringVector_assign", _wrap_StringVector_assign, METH_VARARGS, NULL},
	{ (char *)"StringVector_resize", _wrap_StringVector_resize, METH_VARARGS, NULL},
	{ (char *)"StringVector_insert", _wrap_StringVector_insert, METH_VARARGS, NULL},
	{ (char *)"StringVector_reserve", _wrap_StringVector_reserve, METH_VARARGS, NULL},
	{ (char *)"StringVector_capacity", _wrap_StringVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_StringVector", _wrap_delete_StringVector, METH_VARARGS, NULL},
	{ (char *)"StringVector_swigregister", StringVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntDoublePair", _wrap_new_IntDoublePair, METH_VARARGS, NULL},
	{ (char *)"IntDoublePair_first_set", _wrap_IntDoublePair_first_set, METH_VARARGS, NULL},
	{ (char *)"IntDoublePair_first_get", _wrap_IntDoublePair_first_get, METH_VARARGS, NULL},
	{ (char *)"IntDoublePair_second_set", _wrap_IntDoublePair_second_set, METH_VARARGS, NULL},
	{ (char *)"IntDoublePair_second_get", _wrap_IntDoublePair_second_get, METH_VARARGS, NULL},
	{ (char *)"delete_IntDoublePair", _wrap_delete_IntDoublePair, METH_VARARGS, NULL},
	{ (char *)"IntDoublePair_swigregister", IntDoublePair_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongDoublePair", _wrap_new_LLongDoublePair, METH_VARARGS, NULL},
	{ (char *)"LLongDoublePair_first_set", _wrap_LLongDoublePair_first_set, METH_VARARGS, NULL},
	{ (char *)"LLongDoublePair_first_get", _wrap_LLongDoublePair_first_get, METH_VARARGS, NULL},
	{ (char *)"LLongDoublePair_second_set", _wrap_LLongDoublePair_second_set, METH_VARARGS, NULL},
	{ (char *)"LLongDoublePair_second_get", _wrap_LLongDoublePair_second_get, METH_VARARGS, NULL},
	{ (char *)"delete_LLongDoublePair", _wrap_delete_LLongDoublePair, METH_VARARGS, NULL},
	{ (char *)"LLongDoublePair_swigregister", LLongDoublePair_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleDoublePair", _wrap_new_DoubleDoublePair, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePair_first_set", _wrap_DoubleDoublePair_first_set, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePair_first_get", _wrap_DoubleDoublePair_first_get, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePair_second_set", _wrap_DoubleDoublePair_second_set, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePair_second_get", _wrap_DoubleDoublePair_second_get, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleDoublePair", _wrap_delete_DoubleDoublePair, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePair_swigregister", DoubleDoublePair_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LDoubleLDoublePair", _wrap_new_LDoubleLDoublePair, METH_VARARGS, NULL},
	{ (char *)"LDoubleLDoublePair_first_set", _wrap_LDoubleLDoublePair_first_set, METH_VARARGS, NULL},
	{ (char *)"LDoubleLDoublePair_first_get", _wrap_LDoubleLDoublePair_first_get, METH_VARARGS, NULL},
	{ (char *)"LDoubleLDoublePair_second_set", _wrap_LDoubleLDoublePair_second_set, METH_VARARGS, NULL},
	{ (char *)"LDoubleLDoublePair_second_get", _wrap_LDoubleLDoublePair_second_get, METH_VARARGS, NULL},
	{ (char *)"delete_LDoubleLDoublePair", _wrap_delete_LDoubleLDoublePair, METH_VARARGS, NULL},
	{ (char *)"LDoubleLDoublePair_swigregister", LDoubleLDoublePair_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatDoublePair", _wrap_new_FloatDoublePair, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePair_first_set", _wrap_FloatDoublePair_first_set, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePair_first_get", _wrap_FloatDoublePair_first_get, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePair_second_set", _wrap_FloatDoublePair_second_set, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePair_second_get", _wrap_FloatDoublePair_second_get, METH_VARARGS, NULL},
	{ (char *)"delete_FloatDoublePair", _wrap_delete_FloatDoublePair, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePair_swigregister", FloatDoublePair_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatFloatPair", _wrap_new_FloatFloatPair, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPair_first_set", _wrap_FloatFloatPair_first_set, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPair_first_get", _wrap_FloatFloatPair_first_get, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPair_second_set", _wrap_FloatFloatPair_second_set, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPair_second_get", _wrap_FloatFloatPair_second_get, METH_VARARGS, NULL},
	{ (char *)"delete_FloatFloatPair", _wrap_delete_FloatFloatPair, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPair_swigregister", FloatFloatPair_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleFloatPair", _wrap_new_DoubleFloatPair, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPair_first_set", _wrap_DoubleFloatPair_first_set, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPair_first_get", _wrap_DoubleFloatPair_first_get, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPair_second_set", _wrap_DoubleFloatPair_second_set, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPair_second_get", _wrap_DoubleFloatPair_second_get, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleFloatPair", _wrap_delete_DoubleFloatPair, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPair_swigregister", DoubleFloatPair_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_StringStringPair", _wrap_new_StringStringPair, METH_VARARGS, NULL},
	{ (char *)"StringStringPair_first_set", _wrap_StringStringPair_first_set, METH_VARARGS, NULL},
	{ (char *)"StringStringPair_first_get", _wrap_StringStringPair_first_get, METH_VARARGS, NULL},
	{ (char *)"StringStringPair_second_set", _wrap_StringStringPair_second_set, METH_VARARGS, NULL},
	{ (char *)"StringStringPair_second_get", _wrap_StringStringPair_second_get, METH_VARARGS, NULL},
	{ (char *)"delete_StringStringPair", _wrap_delete_StringStringPair, METH_VARARGS, NULL},
	{ (char *)"StringStringPair_swigregister", StringStringPair_swigregister, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_iterator", _wrap_FloatFloatPairVector_iterator, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector___nonzero__", _wrap_FloatFloatPairVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector___bool__", _wrap_FloatFloatPairVector___bool__, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector___len__", _wrap_FloatFloatPairVector___len__, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector___getslice__", _wrap_FloatFloatPairVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector___setslice__", _wrap_FloatFloatPairVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector___delslice__", _wrap_FloatFloatPairVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector___delitem__", _wrap_FloatFloatPairVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector___getitem__", _wrap_FloatFloatPairVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector___setitem__", _wrap_FloatFloatPairVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_pop", _wrap_FloatFloatPairVector_pop, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_append", _wrap_FloatFloatPairVector_append, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_empty", _wrap_FloatFloatPairVector_empty, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_size", _wrap_FloatFloatPairVector_size, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_swap", _wrap_FloatFloatPairVector_swap, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_begin", _wrap_FloatFloatPairVector_begin, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_end", _wrap_FloatFloatPairVector_end, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_rbegin", _wrap_FloatFloatPairVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_rend", _wrap_FloatFloatPairVector_rend, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_clear", _wrap_FloatFloatPairVector_clear, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_get_allocator", _wrap_FloatFloatPairVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_pop_back", _wrap_FloatFloatPairVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_erase", _wrap_FloatFloatPairVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_FloatFloatPairVector", _wrap_new_FloatFloatPairVector, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_push_back", _wrap_FloatFloatPairVector_push_back, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_front", _wrap_FloatFloatPairVector_front, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_back", _wrap_FloatFloatPairVector_back, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_assign", _wrap_FloatFloatPairVector_assign, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_resize", _wrap_FloatFloatPairVector_resize, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_insert", _wrap_FloatFloatPairVector_insert, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_reserve", _wrap_FloatFloatPairVector_reserve, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_capacity", _wrap_FloatFloatPairVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_FloatFloatPairVector", _wrap_delete_FloatFloatPairVector, METH_VARARGS, NULL},
	{ (char *)"FloatFloatPairVector_swigregister", FloatFloatPairVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_iterator", _wrap_DoubleDoublePairVector_iterator, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector___nonzero__", _wrap_DoubleDoublePairVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector___bool__", _wrap_DoubleDoublePairVector___bool__, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector___len__", _wrap_DoubleDoublePairVector___len__, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector___getslice__", _wrap_DoubleDoublePairVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector___setslice__", _wrap_DoubleDoublePairVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector___delslice__", _wrap_DoubleDoublePairVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector___delitem__", _wrap_DoubleDoublePairVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector___getitem__", _wrap_DoubleDoublePairVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector___setitem__", _wrap_DoubleDoublePairVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_pop", _wrap_DoubleDoublePairVector_pop, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_append", _wrap_DoubleDoublePairVector_append, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_empty", _wrap_DoubleDoublePairVector_empty, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_size", _wrap_DoubleDoublePairVector_size, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_swap", _wrap_DoubleDoublePairVector_swap, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_begin", _wrap_DoubleDoublePairVector_begin, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_end", _wrap_DoubleDoublePairVector_end, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_rbegin", _wrap_DoubleDoublePairVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_rend", _wrap_DoubleDoublePairVector_rend, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_clear", _wrap_DoubleDoublePairVector_clear, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_get_allocator", _wrap_DoubleDoublePairVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_pop_back", _wrap_DoubleDoublePairVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_erase", _wrap_DoubleDoublePairVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_DoubleDoublePairVector", _wrap_new_DoubleDoublePairVector, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_push_back", _wrap_DoubleDoublePairVector_push_back, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_front", _wrap_DoubleDoublePairVector_front, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_back", _wrap_DoubleDoublePairVector_back, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_assign", _wrap_DoubleDoublePairVector_assign, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_resize", _wrap_DoubleDoublePairVector_resize, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_insert", _wrap_DoubleDoublePairVector_insert, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_reserve", _wrap_DoubleDoublePairVector_reserve, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_capacity", _wrap_DoubleDoublePairVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleDoublePairVector", _wrap_delete_DoubleDoublePairVector, METH_VARARGS, NULL},
	{ (char *)"DoubleDoublePairVector_swigregister", DoubleDoublePairVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_iterator", _wrap_FloatDoublePairVector_iterator, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector___nonzero__", _wrap_FloatDoublePairVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector___bool__", _wrap_FloatDoublePairVector___bool__, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector___len__", _wrap_FloatDoublePairVector___len__, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector___getslice__", _wrap_FloatDoublePairVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector___setslice__", _wrap_FloatDoublePairVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector___delslice__", _wrap_FloatDoublePairVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector___delitem__", _wrap_FloatDoublePairVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector___getitem__", _wrap_FloatDoublePairVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector___setitem__", _wrap_FloatDoublePairVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_pop", _wrap_FloatDoublePairVector_pop, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_append", _wrap_FloatDoublePairVector_append, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_empty", _wrap_FloatDoublePairVector_empty, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_size", _wrap_FloatDoublePairVector_size, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_swap", _wrap_FloatDoublePairVector_swap, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_begin", _wrap_FloatDoublePairVector_begin, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_end", _wrap_FloatDoublePairVector_end, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_rbegin", _wrap_FloatDoublePairVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_rend", _wrap_FloatDoublePairVector_rend, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_clear", _wrap_FloatDoublePairVector_clear, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_get_allocator", _wrap_FloatDoublePairVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_pop_back", _wrap_FloatDoublePairVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_erase", _wrap_FloatDoublePairVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_FloatDoublePairVector", _wrap_new_FloatDoublePairVector, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_push_back", _wrap_FloatDoublePairVector_push_back, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_front", _wrap_FloatDoublePairVector_front, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_back", _wrap_FloatDoublePairVector_back, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_assign", _wrap_FloatDoublePairVector_assign, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_resize", _wrap_FloatDoublePairVector_resize, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_insert", _wrap_FloatDoublePairVector_insert, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_reserve", _wrap_FloatDoublePairVector_reserve, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_capacity", _wrap_FloatDoublePairVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_FloatDoublePairVector", _wrap_delete_FloatDoublePairVector, METH_VARARGS, NULL},
	{ (char *)"FloatDoublePairVector_swigregister", FloatDoublePairVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_iterator", _wrap_DoubleFloatPairVector_iterator, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector___nonzero__", _wrap_DoubleFloatPairVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector___bool__", _wrap_DoubleFloatPairVector___bool__, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector___len__", _wrap_DoubleFloatPairVector___len__, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector___getslice__", _wrap_DoubleFloatPairVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector___setslice__", _wrap_DoubleFloatPairVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector___delslice__", _wrap_DoubleFloatPairVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector___delitem__", _wrap_DoubleFloatPairVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector___getitem__", _wrap_DoubleFloatPairVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector___setitem__", _wrap_DoubleFloatPairVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_pop", _wrap_DoubleFloatPairVector_pop, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_append", _wrap_DoubleFloatPairVector_append, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_empty", _wrap_DoubleFloatPairVector_empty, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_size", _wrap_DoubleFloatPairVector_size, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_swap", _wrap_DoubleFloatPairVector_swap, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_begin", _wrap_DoubleFloatPairVector_begin, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_end", _wrap_DoubleFloatPairVector_end, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_rbegin", _wrap_DoubleFloatPairVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_rend", _wrap_DoubleFloatPairVector_rend, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_clear", _wrap_DoubleFloatPairVector_clear, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_get_allocator", _wrap_DoubleFloatPairVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_pop_back", _wrap_DoubleFloatPairVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_erase", _wrap_DoubleFloatPairVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_DoubleFloatPairVector", _wrap_new_DoubleFloatPairVector, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_push_back", _wrap_DoubleFloatPairVector_push_back, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_front", _wrap_DoubleFloatPairVector_front, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_back", _wrap_DoubleFloatPairVector_back, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_assign", _wrap_DoubleFloatPairVector_assign, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_resize", _wrap_DoubleFloatPairVector_resize, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_insert", _wrap_DoubleFloatPairVector_insert, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_reserve", _wrap_DoubleFloatPairVector_reserve, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_capacity", _wrap_DoubleFloatPairVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleFloatPairVector", _wrap_delete_DoubleFloatPairVector, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatPairVector_swigregister", DoubleFloatPairVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_iterator", _wrap_FloatVectorVector_iterator, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector___nonzero__", _wrap_FloatVectorVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector___bool__", _wrap_FloatVectorVector___bool__, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector___len__", _wrap_FloatVectorVector___len__, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector___getslice__", _wrap_FloatVectorVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector___setslice__", _wrap_FloatVectorVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector___delslice__", _wrap_FloatVectorVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector___delitem__", _wrap_FloatVectorVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector___getitem__", _wrap_FloatVectorVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector___setitem__", _wrap_FloatVectorVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_pop", _wrap_FloatVectorVector_pop, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_append", _wrap_FloatVectorVector_append, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_empty", _wrap_FloatVectorVector_empty, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_size", _wrap_FloatVectorVector_size, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_swap", _wrap_FloatVectorVector_swap, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_begin", _wrap_FloatVectorVector_begin, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_end", _wrap_FloatVectorVector_end, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_rbegin", _wrap_FloatVectorVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_rend", _wrap_FloatVectorVector_rend, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_clear", _wrap_FloatVectorVector_clear, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_get_allocator", _wrap_FloatVectorVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_pop_back", _wrap_FloatVectorVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_erase", _wrap_FloatVectorVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_FloatVectorVector", _wrap_new_FloatVectorVector, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_push_back", _wrap_FloatVectorVector_push_back, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_front", _wrap_FloatVectorVector_front, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_back", _wrap_FloatVectorVector_back, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_assign", _wrap_FloatVectorVector_assign, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_resize", _wrap_FloatVectorVector_resize, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_insert", _wrap_FloatVectorVector_insert, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_reserve", _wrap_FloatVectorVector_reserve, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_capacity", _wrap_FloatVectorVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_FloatVectorVector", _wrap_delete_FloatVectorVector, METH_VARARGS, NULL},
	{ (char *)"FloatVectorVector_swigregister", FloatVectorVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_iterator", _wrap_DoubleVectorVector_iterator, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector___nonzero__", _wrap_DoubleVectorVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector___bool__", _wrap_DoubleVectorVector___bool__, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector___len__", _wrap_DoubleVectorVector___len__, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector___getslice__", _wrap_DoubleVectorVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector___setslice__", _wrap_DoubleVectorVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector___delslice__", _wrap_DoubleVectorVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector___delitem__", _wrap_DoubleVectorVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector___getitem__", _wrap_DoubleVectorVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector___setitem__", _wrap_DoubleVectorVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_pop", _wrap_DoubleVectorVector_pop, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_append", _wrap_DoubleVectorVector_append, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_empty", _wrap_DoubleVectorVector_empty, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_size", _wrap_DoubleVectorVector_size, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_swap", _wrap_DoubleVectorVector_swap, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_begin", _wrap_DoubleVectorVector_begin, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_end", _wrap_DoubleVectorVector_end, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_rbegin", _wrap_DoubleVectorVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_rend", _wrap_DoubleVectorVector_rend, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_clear", _wrap_DoubleVectorVector_clear, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_get_allocator", _wrap_DoubleVectorVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_pop_back", _wrap_DoubleVectorVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_erase", _wrap_DoubleVectorVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_DoubleVectorVector", _wrap_new_DoubleVectorVector, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_push_back", _wrap_DoubleVectorVector_push_back, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_front", _wrap_DoubleVectorVector_front, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_back", _wrap_DoubleVectorVector_back, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_assign", _wrap_DoubleVectorVector_assign, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_resize", _wrap_DoubleVectorVector_resize, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_insert", _wrap_DoubleVectorVector_insert, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_reserve", _wrap_DoubleVectorVector_reserve, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_capacity", _wrap_DoubleVectorVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleVectorVector", _wrap_delete_DoubleVectorVector, METH_VARARGS, NULL},
	{ (char *)"DoubleVectorVector_swigregister", DoubleVectorVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"getBool", _wrap_getBool, METH_VARARGS, NULL},
	{ (char *)"getChar", _wrap_getChar, METH_VARARGS, NULL},
	{ (char *)"getUChar", _wrap_getUChar, METH_VARARGS, NULL},
	{ (char *)"getSChar", _wrap_getSChar, METH_VARARGS, NULL},
	{ (char *)"getShort", _wrap_getShort, METH_VARARGS, NULL},
	{ (char *)"getUShort", _wrap_getUShort, METH_VARARGS, NULL},
	{ (char *)"getInt", _wrap_getInt, METH_VARARGS, NULL},
	{ (char *)"getLong", _wrap_getLong, METH_VARARGS, NULL},
	{ (char *)"getLLong", _wrap_getLLong, METH_VARARGS, NULL},
	{ (char *)"getUInt", _wrap_getUInt, METH_VARARGS, NULL},
	{ (char *)"getULong", _wrap_getULong, METH_VARARGS, NULL},
	{ (char *)"getULLong", _wrap_getULLong, METH_VARARGS, NULL},
	{ (char *)"getFloat", _wrap_getFloat, METH_VARARGS, NULL},
	{ (char *)"getDouble", _wrap_getDouble, METH_VARARGS, NULL},
	{ (char *)"getLDouble", _wrap_getLDouble, METH_VARARGS, NULL},
	{ (char *)"getCFloat", _wrap_getCFloat, METH_VARARGS, NULL},
	{ (char *)"getCDouble", _wrap_getCDouble, METH_VARARGS, NULL},
	{ (char *)"getCLDouble", _wrap_getCLDouble, METH_VARARGS, NULL},
	{ (char *)"getString", _wrap_getString, METH_VARARGS, NULL},
	{ (char *)"assignBool", _wrap_assignBool, METH_VARARGS, NULL},
	{ (char *)"assignChar", _wrap_assignChar, METH_VARARGS, NULL},
	{ (char *)"assignUChar", _wrap_assignUChar, METH_VARARGS, NULL},
	{ (char *)"assignSChar", _wrap_assignSChar, METH_VARARGS, NULL},
	{ (char *)"assignShort", _wrap_assignShort, METH_VARARGS, NULL},
	{ (char *)"assignUShort", _wrap_assignUShort, METH_VARARGS, NULL},
	{ (char *)"assignInt", _wrap_assignInt, METH_VARARGS, NULL},
	{ (char *)"assignLong", _wrap_assignLong, METH_VARARGS, NULL},
	{ (char *)"assignLLong", _wrap_assignLLong, METH_VARARGS, NULL},
	{ (char *)"assignUInt", _wrap_assignUInt, METH_VARARGS, NULL},
	{ (char *)"assignULong", _wrap_assignULong, METH_VARARGS, NULL},
	{ (char *)"assignULLong", _wrap_assignULLong, METH_VARARGS, NULL},
	{ (char *)"assignFloat", _wrap_assignFloat, METH_VARARGS, NULL},
	{ (char *)"assignDouble", _wrap_assignDouble, METH_VARARGS, NULL},
	{ (char *)"assignLDouble", _wrap_assignLDouble, METH_VARARGS, NULL},
	{ (char *)"assignCFloat", _wrap_assignCFloat, METH_VARARGS, NULL},
	{ (char *)"assignCDouble", _wrap_assignCDouble, METH_VARARGS, NULL},
	{ (char *)"assignCLDouble", _wrap_assignCLDouble, METH_VARARGS, NULL},
	{ (char *)"assignString", _wrap_assignString, METH_VARARGS, NULL},
	{ (char *)"delete_AbsRandomGenerator", _wrap_delete_AbsRandomGenerator, METH_VARARGS, NULL},
	{ (char *)"AbsRandomGenerator_dim", _wrap_AbsRandomGenerator_dim, METH_VARARGS, NULL},
	{ (char *)"AbsRandomGenerator_maxPoints", _wrap_AbsRandomGenerator_maxPoints, METH_VARARGS, NULL},
	{ (char *)"AbsRandomGenerator___call__", _wrap_AbsRandomGenerator___call__, METH_VARARGS, NULL},
	{ (char *)"AbsRandomGenerator_run", _wrap_AbsRandomGenerator_run, METH_VARARGS, NULL},
	{ (char *)"AbsRandomGenerator_generate", _wrap_AbsRandomGenerator_generate, METH_VARARGS, NULL},
	{ (char *)"AbsRandomGenerator_swigregister", AbsRandomGenerator_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_WrappedRandomGen", _wrap_new_WrappedRandomGen, METH_VARARGS, NULL},
	{ (char *)"delete_WrappedRandomGen", _wrap_delete_WrappedRandomGen, METH_VARARGS, NULL},
	{ (char *)"WrappedRandomGen_dim", _wrap_WrappedRandomGen_dim, METH_VARARGS, NULL},
	{ (char *)"WrappedRandomGen___call__", _wrap_WrappedRandomGen___call__, METH_VARARGS, NULL},
	{ (char *)"WrappedRandomGen_swigregister", WrappedRandomGen_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_MersenneTwister", _wrap_new_MersenneTwister, METH_VARARGS, NULL},
	{ (char *)"delete_MersenneTwister", _wrap_delete_MersenneTwister, METH_VARARGS, NULL},
	{ (char *)"MersenneTwister_dim", _wrap_MersenneTwister_dim, METH_VARARGS, NULL},
	{ (char *)"MersenneTwister___call__", _wrap_MersenneTwister___call__, METH_VARARGS, NULL},
	{ (char *)"MersenneTwister_swigregister", MersenneTwister_swigregister, METH_VARARGS, NULL},
	{ (char *)"orderedPermutation", _wrap_orderedPermutation, METH_VARARGS, NULL},
	{ (char *)"randomPermutation", _wrap_randomPermutation, METH_VARARGS, NULL},
	{ (char *)"permutationNumber", _wrap_permutationNumber, METH_VARARGS, NULL},
	{ (char *)"factorial", _wrap_factorial, METH_VARARGS, NULL},
	{ (char *)"intPower", _wrap_intPower, METH_VARARGS, NULL},
	{ (char *)"ldfactorial", _wrap_ldfactorial, METH_VARARGS, NULL},
	{ (char *)"logfactorial", _wrap_logfactorial, METH_VARARGS, NULL},
	{ (char *)"new_RegularSampler1D", _wrap_new_RegularSampler1D, METH_VARARGS, NULL},
	{ (char *)"delete_RegularSampler1D", _wrap_delete_RegularSampler1D, METH_VARARGS, NULL},
	{ (char *)"RegularSampler1D_dim", _wrap_RegularSampler1D_dim, METH_VARARGS, NULL},
	{ (char *)"RegularSampler1D_nCalls", _wrap_RegularSampler1D_nCalls, METH_VARARGS, NULL},
	{ (char *)"RegularSampler1D___call__", _wrap_RegularSampler1D___call__, METH_VARARGS, NULL},
	{ (char *)"RegularSampler1D_reset", _wrap_RegularSampler1D_reset, METH_VARARGS, NULL},
	{ (char *)"RegularSampler1D_uniformCount", _wrap_RegularSampler1D_uniformCount, METH_VARARGS, NULL},
	{ (char *)"RegularSampler1D_swigregister", RegularSampler1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_SobolGenerator", _wrap_new_SobolGenerator, METH_VARARGS, NULL},
	{ (char *)"delete_SobolGenerator", _wrap_delete_SobolGenerator, METH_VARARGS, NULL},
	{ (char *)"SobolGenerator_dim", _wrap_SobolGenerator_dim, METH_VARARGS, NULL},
	{ (char *)"SobolGenerator_run", _wrap_SobolGenerator_run, METH_VARARGS, NULL},
	{ (char *)"SobolGenerator___call__", _wrap_SobolGenerator___call__, METH_VARARGS, NULL},
	{ (char *)"SobolGenerator_maxPoints", _wrap_SobolGenerator_maxPoints, METH_VARARGS, NULL},
	{ (char *)"SobolGenerator_swigregister", SobolGenerator_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_HOSobolGenerator", _wrap_new_HOSobolGenerator, METH_VARARGS, NULL},
	{ (char *)"delete_HOSobolGenerator", _wrap_delete_HOSobolGenerator, METH_VARARGS, NULL},
	{ (char *)"HOSobolGenerator_dim", _wrap_HOSobolGenerator_dim, METH_VARARGS, NULL},
	{ (char *)"HOSobolGenerator_run", _wrap_HOSobolGenerator_run, METH_VARARGS, NULL},
	{ (char *)"HOSobolGenerator_swigregister", HOSobolGenerator_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_EquidistantSampler1D", _wrap_new_EquidistantSampler1D, METH_VARARGS, NULL},
	{ (char *)"delete_EquidistantSampler1D", _wrap_delete_EquidistantSampler1D, METH_VARARGS, NULL},
	{ (char *)"EquidistantSampler1D_dim", _wrap_EquidistantSampler1D_dim, METH_VARARGS, NULL},
	{ (char *)"EquidistantSampler1D_nCalls", _wrap_EquidistantSampler1D_nCalls, METH_VARARGS, NULL},
	{ (char *)"EquidistantSampler1D_maxPoints", _wrap_EquidistantSampler1D_maxPoints, METH_VARARGS, NULL},
	{ (char *)"EquidistantSampler1D___call__", _wrap_EquidistantSampler1D___call__, METH_VARARGS, NULL},
	{ (char *)"EquidistantSampler1D_reset", _wrap_EquidistantSampler1D_reset, METH_VARARGS, NULL},
	{ (char *)"EquidistantSampler1D_swigregister", EquidistantSampler1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"convertToSphericalRandom", _wrap_convertToSphericalRandom, METH_VARARGS, NULL},
	{ (char *)"new_RandomSequenceRepeater", _wrap_new_RandomSequenceRepeater, METH_VARARGS, NULL},
	{ (char *)"delete_RandomSequenceRepeater", _wrap_delete_RandomSequenceRepeater, METH_VARARGS, NULL},
	{ (char *)"RandomSequenceRepeater_dim", _wrap_RandomSequenceRepeater_dim, METH_VARARGS, NULL},
	{ (char *)"RandomSequenceRepeater___call__", _wrap_RandomSequenceRepeater___call__, METH_VARARGS, NULL},
	{ (char *)"RandomSequenceRepeater_run", _wrap_RandomSequenceRepeater_run, METH_VARARGS, NULL},
	{ (char *)"RandomSequenceRepeater_repeat", _wrap_RandomSequenceRepeater_repeat, METH_VARARGS, NULL},
	{ (char *)"RandomSequenceRepeater_clear", _wrap_RandomSequenceRepeater_clear, METH_VARARGS, NULL},
	{ (char *)"RandomSequenceRepeater_skip", _wrap_RandomSequenceRepeater_skip, METH_VARARGS, NULL},
	{ (char *)"RandomSequenceRepeater_swigregister", RandomSequenceRepeater_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Column", _wrap_new_Column, METH_VARARGS, NULL},
	{ (char *)"delete_Column", _wrap_delete_Column, METH_VARARGS, NULL},
	{ (char *)"Column_swigregister", Column_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ClassId", _wrap_new_ClassId, METH_VARARGS, NULL},
	{ (char *)"ClassId_name", _wrap_ClassId_name, METH_VARARGS, NULL},
	{ (char *)"ClassId_version", _wrap_ClassId_version, METH_VARARGS, NULL},
	{ (char *)"ClassId_isPointer", _wrap_ClassId_isPointer, METH_VARARGS, NULL},
	{ (char *)"ClassId_id", _wrap_ClassId_id, METH_VARARGS, NULL},
	{ (char *)"ClassId_isTemplate", _wrap_ClassId_isTemplate, METH_VARARGS, NULL},
	{ (char *)"ClassId_write", _wrap_ClassId_write, METH_VARARGS, NULL},
	{ (char *)"ClassId___eq__", _wrap_ClassId___eq__, METH_VARARGS, NULL},
	{ (char *)"ClassId___ne__", _wrap_ClassId___ne__, METH_VARARGS, NULL},
	{ (char *)"ClassId___lt__", _wrap_ClassId___lt__, METH_VARARGS, NULL},
	{ (char *)"ClassId___gt__", _wrap_ClassId___gt__, METH_VARARGS, NULL},
	{ (char *)"ClassId_setVersion", _wrap_ClassId_setVersion, METH_VARARGS, NULL},
	{ (char *)"ClassId_ensureSameId", _wrap_ClassId_ensureSameId, METH_VARARGS, NULL},
	{ (char *)"ClassId_ensureSameName", _wrap_ClassId_ensureSameName, METH_VARARGS, NULL},
	{ (char *)"ClassId_ensureSameVersion", _wrap_ClassId_ensureSameVersion, METH_VARARGS, NULL},
	{ (char *)"ClassId_ensureVersionInRange", _wrap_ClassId_ensureVersionInRange, METH_VARARGS, NULL},
	{ (char *)"ClassId_invalidId", _wrap_ClassId_invalidId, METH_VARARGS, NULL},
	{ (char *)"delete_ClassId", _wrap_delete_ClassId, METH_VARARGS, NULL},
	{ (char *)"ClassId_swigregister", ClassId_swigregister, METH_VARARGS, NULL},
	{ (char *)"SameClassId_compatible", _wrap_SameClassId_compatible, METH_VARARGS, NULL},
	{ (char *)"new_SameClassId", _wrap_new_SameClassId, METH_VARARGS, NULL},
	{ (char *)"delete_SameClassId", _wrap_delete_SameClassId, METH_VARARGS, NULL},
	{ (char *)"SameClassId_swigregister", SameClassId_swigregister, METH_VARARGS, NULL},
	{ (char *)"SameClassName_compatible", _wrap_SameClassName_compatible, METH_VARARGS, NULL},
	{ (char *)"new_SameClassName", _wrap_new_SameClassName, METH_VARARGS, NULL},
	{ (char *)"delete_SameClassName", _wrap_delete_SameClassName, METH_VARARGS, NULL},
	{ (char *)"SameClassName_swigregister", SameClassName_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatSampleAccumulator", _wrap_new_FloatSampleAccumulator, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_count", _wrap_FloatSampleAccumulator_count, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_min", _wrap_FloatSampleAccumulator_min, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_max", _wrap_FloatSampleAccumulator_max, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_mean", _wrap_FloatSampleAccumulator_mean, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_stdev", _wrap_FloatSampleAccumulator_stdev, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_meanUncertainty", _wrap_FloatSampleAccumulator_meanUncertainty, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_median", _wrap_FloatSampleAccumulator_median, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_cdf", _wrap_FloatSampleAccumulator_cdf, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_nBelow", _wrap_FloatSampleAccumulator_nBelow, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_quantile", _wrap_FloatSampleAccumulator_quantile, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_location", _wrap_FloatSampleAccumulator_location, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_rangeDown", _wrap_FloatSampleAccumulator_rangeDown, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_rangeUp", _wrap_FloatSampleAccumulator_rangeUp, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_sigmaRange", _wrap_FloatSampleAccumulator_sigmaRange, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_noThrowMean", _wrap_FloatSampleAccumulator_noThrowMean, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_noThrowStdev", _wrap_FloatSampleAccumulator_noThrowStdev, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_noThrowMeanUncertainty", _wrap_FloatSampleAccumulator_noThrowMeanUncertainty, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_data", _wrap_FloatSampleAccumulator_data, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator___eq__", _wrap_FloatSampleAccumulator___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator___ne__", _wrap_FloatSampleAccumulator___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_accumulate", _wrap_FloatSampleAccumulator_accumulate, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator___iadd__", _wrap_FloatSampleAccumulator___iadd__, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator___add__", _wrap_FloatSampleAccumulator___add__, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_reset", _wrap_FloatSampleAccumulator_reset, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_reserve", _wrap_FloatSampleAccumulator_reserve, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_classId", _wrap_FloatSampleAccumulator_classId, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_write", _wrap_FloatSampleAccumulator_write, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_classname", _wrap_FloatSampleAccumulator_classname, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_version", _wrap_FloatSampleAccumulator_version, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_restore", _wrap_FloatSampleAccumulator_restore, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator___mul__", _wrap_FloatSampleAccumulator___mul__, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator___div__", _wrap_FloatSampleAccumulator___div__, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator___imul__", _wrap_FloatSampleAccumulator___imul__, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator___idiv__", _wrap_FloatSampleAccumulator___idiv__, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_cov", _wrap_FloatSampleAccumulator_cov, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_corr", _wrap_FloatSampleAccumulator_corr, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_accumulateAll", _wrap_FloatSampleAccumulator_accumulateAll, METH_VARARGS, NULL},
	{ (char *)"delete_FloatSampleAccumulator", _wrap_delete_FloatSampleAccumulator, METH_VARARGS, NULL},
	{ (char *)"FloatSampleAccumulator_swigregister", FloatSampleAccumulator_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleSampleAccumulator", _wrap_new_DoubleSampleAccumulator, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_count", _wrap_DoubleSampleAccumulator_count, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_min", _wrap_DoubleSampleAccumulator_min, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_max", _wrap_DoubleSampleAccumulator_max, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_mean", _wrap_DoubleSampleAccumulator_mean, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_stdev", _wrap_DoubleSampleAccumulator_stdev, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_meanUncertainty", _wrap_DoubleSampleAccumulator_meanUncertainty, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_median", _wrap_DoubleSampleAccumulator_median, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_cdf", _wrap_DoubleSampleAccumulator_cdf, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_nBelow", _wrap_DoubleSampleAccumulator_nBelow, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_quantile", _wrap_DoubleSampleAccumulator_quantile, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_location", _wrap_DoubleSampleAccumulator_location, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_rangeDown", _wrap_DoubleSampleAccumulator_rangeDown, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_rangeUp", _wrap_DoubleSampleAccumulator_rangeUp, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_sigmaRange", _wrap_DoubleSampleAccumulator_sigmaRange, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_noThrowMean", _wrap_DoubleSampleAccumulator_noThrowMean, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_noThrowStdev", _wrap_DoubleSampleAccumulator_noThrowStdev, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_noThrowMeanUncertainty", _wrap_DoubleSampleAccumulator_noThrowMeanUncertainty, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_data", _wrap_DoubleSampleAccumulator_data, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator___eq__", _wrap_DoubleSampleAccumulator___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator___ne__", _wrap_DoubleSampleAccumulator___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_accumulate", _wrap_DoubleSampleAccumulator_accumulate, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator___iadd__", _wrap_DoubleSampleAccumulator___iadd__, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator___add__", _wrap_DoubleSampleAccumulator___add__, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_reset", _wrap_DoubleSampleAccumulator_reset, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_reserve", _wrap_DoubleSampleAccumulator_reserve, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_classId", _wrap_DoubleSampleAccumulator_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_write", _wrap_DoubleSampleAccumulator_write, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_classname", _wrap_DoubleSampleAccumulator_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_version", _wrap_DoubleSampleAccumulator_version, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_restore", _wrap_DoubleSampleAccumulator_restore, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator___mul__", _wrap_DoubleSampleAccumulator___mul__, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator___div__", _wrap_DoubleSampleAccumulator___div__, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator___imul__", _wrap_DoubleSampleAccumulator___imul__, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator___idiv__", _wrap_DoubleSampleAccumulator___idiv__, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_cov", _wrap_DoubleSampleAccumulator_cov, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_corr", _wrap_DoubleSampleAccumulator_corr, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_accumulateAll", _wrap_DoubleSampleAccumulator_accumulateAll, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleSampleAccumulator", _wrap_delete_DoubleSampleAccumulator, METH_VARARGS, NULL},
	{ (char *)"DoubleSampleAccumulator_swigregister", DoubleSampleAccumulator_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ItemDescriptor", _wrap_new_ItemDescriptor, METH_VARARGS, NULL},
	{ (char *)"delete_ItemDescriptor", _wrap_delete_ItemDescriptor, METH_VARARGS, NULL},
	{ (char *)"ItemDescriptor_type", _wrap_ItemDescriptor_type, METH_VARARGS, NULL},
	{ (char *)"ItemDescriptor_ioPrototype", _wrap_ItemDescriptor_ioPrototype, METH_VARARGS, NULL},
	{ (char *)"ItemDescriptor_name", _wrap_ItemDescriptor_name, METH_VARARGS, NULL},
	{ (char *)"ItemDescriptor_category", _wrap_ItemDescriptor_category, METH_VARARGS, NULL},
	{ (char *)"ItemDescriptor_nameAndCategory", _wrap_ItemDescriptor_nameAndCategory, METH_VARARGS, NULL},
	{ (char *)"ItemDescriptor___eq__", _wrap_ItemDescriptor___eq__, METH_VARARGS, NULL},
	{ (char *)"ItemDescriptor___ne__", _wrap_ItemDescriptor___ne__, METH_VARARGS, NULL},
	{ (char *)"ItemDescriptor_isSameClassIdandIO", _wrap_ItemDescriptor_isSameClassIdandIO, METH_VARARGS, NULL},
	{ (char *)"ItemDescriptor_isSameIOPrototype", _wrap_ItemDescriptor_isSameIOPrototype, METH_VARARGS, NULL},
	{ (char *)"ItemDescriptor_getName", _wrap_ItemDescriptor_getName, METH_VARARGS, NULL},
	{ (char *)"ItemDescriptor_getCategory", _wrap_ItemDescriptor_getCategory, METH_VARARGS, NULL},
	{ (char *)"ItemDescriptor_swigregister", ItemDescriptor_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsRecord", _wrap_delete_AbsRecord, METH_VARARGS, NULL},
	{ (char *)"AbsRecord_id", _wrap_AbsRecord_id, METH_VARARGS, NULL},
	{ (char *)"AbsRecord_itemLength", _wrap_AbsRecord_itemLength, METH_VARARGS, NULL},
	{ (char *)"AbsRecord_swigregister", AbsRecord_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_SearchSpecifier", _wrap_new_SearchSpecifier, METH_VARARGS, NULL},
	{ (char *)"SearchSpecifier_useRegex", _wrap_SearchSpecifier_useRegex, METH_VARARGS, NULL},
	{ (char *)"SearchSpecifier_pattern", _wrap_SearchSpecifier_pattern, METH_VARARGS, NULL},
	{ (char *)"SearchSpecifier_matches", _wrap_SearchSpecifier_matches, METH_VARARGS, NULL},
	{ (char *)"SearchSpecifier_getPattern", _wrap_SearchSpecifier_getPattern, METH_VARARGS, NULL},
	{ (char *)"delete_SearchSpecifier", _wrap_delete_SearchSpecifier, METH_VARARGS, NULL},
	{ (char *)"SearchSpecifier_swigregister", SearchSpecifier_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsReference", _wrap_delete_AbsReference, METH_VARARGS, NULL},
	{ (char *)"AbsReference_archive", _wrap_AbsReference_archive, METH_VARARGS, NULL},
	{ (char *)"AbsReference_type", _wrap_AbsReference_type, METH_VARARGS, NULL},
	{ (char *)"AbsReference_ioPrototype", _wrap_AbsReference_ioPrototype, METH_VARARGS, NULL},
	{ (char *)"AbsReference_namePattern", _wrap_AbsReference_namePattern, METH_VARARGS, NULL},
	{ (char *)"AbsReference_categoryPattern", _wrap_AbsReference_categoryPattern, METH_VARARGS, NULL},
	{ (char *)"AbsReference_isIOCompatible", _wrap_AbsReference_isIOCompatible, METH_VARARGS, NULL},
	{ (char *)"AbsReference_isSameIOPrototype", _wrap_AbsReference_isSameIOPrototype, METH_VARARGS, NULL},
	{ (char *)"AbsReference_empty", _wrap_AbsReference_empty, METH_VARARGS, NULL},
	{ (char *)"AbsReference_unique", _wrap_AbsReference_unique, METH_VARARGS, NULL},
	{ (char *)"AbsReference_size", _wrap_AbsReference_size, METH_VARARGS, NULL},
	{ (char *)"AbsReference_id", _wrap_AbsReference_id, METH_VARARGS, NULL},
	{ (char *)"AbsReference_indexedCatalogEntry", _wrap_AbsReference_indexedCatalogEntry, METH_VARARGS, NULL},
	{ (char *)"AbsReference_swigregister", AbsReference_swigregister, METH_VARARGS, NULL},
	{ (char *)"makeShape", _wrap_makeShape, METH_VARARGS, NULL},
	{ (char *)"doubleShape", _wrap_doubleShape, METH_VARARGS, NULL},
	{ (char *)"halfShape", _wrap_halfShape, METH_VARARGS, NULL},
	{ (char *)"isSubShape", _wrap_isSubShape, METH_VARARGS, NULL},
	{ (char *)"new_UCharInterval", _wrap_new_UCharInterval, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_setMin", _wrap_UCharInterval_setMin, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_setMax", _wrap_UCharInterval_setMax, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_setBounds", _wrap_UCharInterval_setBounds, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_min", _wrap_UCharInterval_min, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_max", _wrap_UCharInterval_max, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_getBounds", _wrap_UCharInterval_getBounds, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_length", _wrap_UCharInterval_length, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_midpoint", _wrap_UCharInterval_midpoint, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_isInsideLower", _wrap_UCharInterval_isInsideLower, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_isInsideUpper", _wrap_UCharInterval_isInsideUpper, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_isInsideWithBounds", _wrap_UCharInterval_isInsideWithBounds, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_isInside", _wrap_UCharInterval_isInside, METH_VARARGS, NULL},
	{ (char *)"UCharInterval___imul__", _wrap_UCharInterval___imul__, METH_VARARGS, NULL},
	{ (char *)"UCharInterval___itruediv__", _wrap_UCharInterval___itruediv__, METH_VARARGS, NULL},
	{ (char *)"UCharInterval___iadd__", _wrap_UCharInterval___iadd__, METH_VARARGS, NULL},
	{ (char *)"UCharInterval___isub__", _wrap_UCharInterval___isub__, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_moveMidpointTo0", _wrap_UCharInterval_moveMidpointTo0, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_expand", _wrap_UCharInterval_expand, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_overlap", _wrap_UCharInterval_overlap, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_overlapLength", _wrap_UCharInterval_overlapLength, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_overlapFraction", _wrap_UCharInterval_overlapFraction, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_logicalDifference", _wrap_UCharInterval_logicalDifference, METH_VARARGS, NULL},
	{ (char *)"delete_UCharInterval", _wrap_delete_UCharInterval, METH_VARARGS, NULL},
	{ (char *)"UCharInterval_swigregister", UCharInterval_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntInterval", _wrap_new_IntInterval, METH_VARARGS, NULL},
	{ (char *)"IntInterval_setMin", _wrap_IntInterval_setMin, METH_VARARGS, NULL},
	{ (char *)"IntInterval_setMax", _wrap_IntInterval_setMax, METH_VARARGS, NULL},
	{ (char *)"IntInterval_setBounds", _wrap_IntInterval_setBounds, METH_VARARGS, NULL},
	{ (char *)"IntInterval_min", _wrap_IntInterval_min, METH_VARARGS, NULL},
	{ (char *)"IntInterval_max", _wrap_IntInterval_max, METH_VARARGS, NULL},
	{ (char *)"IntInterval_getBounds", _wrap_IntInterval_getBounds, METH_VARARGS, NULL},
	{ (char *)"IntInterval_length", _wrap_IntInterval_length, METH_VARARGS, NULL},
	{ (char *)"IntInterval_midpoint", _wrap_IntInterval_midpoint, METH_VARARGS, NULL},
	{ (char *)"IntInterval_isInsideLower", _wrap_IntInterval_isInsideLower, METH_VARARGS, NULL},
	{ (char *)"IntInterval_isInsideUpper", _wrap_IntInterval_isInsideUpper, METH_VARARGS, NULL},
	{ (char *)"IntInterval_isInsideWithBounds", _wrap_IntInterval_isInsideWithBounds, METH_VARARGS, NULL},
	{ (char *)"IntInterval_isInside", _wrap_IntInterval_isInside, METH_VARARGS, NULL},
	{ (char *)"IntInterval___imul__", _wrap_IntInterval___imul__, METH_VARARGS, NULL},
	{ (char *)"IntInterval___itruediv__", _wrap_IntInterval___itruediv__, METH_VARARGS, NULL},
	{ (char *)"IntInterval___iadd__", _wrap_IntInterval___iadd__, METH_VARARGS, NULL},
	{ (char *)"IntInterval___isub__", _wrap_IntInterval___isub__, METH_VARARGS, NULL},
	{ (char *)"IntInterval_moveMidpointTo0", _wrap_IntInterval_moveMidpointTo0, METH_VARARGS, NULL},
	{ (char *)"IntInterval_expand", _wrap_IntInterval_expand, METH_VARARGS, NULL},
	{ (char *)"IntInterval_overlap", _wrap_IntInterval_overlap, METH_VARARGS, NULL},
	{ (char *)"IntInterval_overlapLength", _wrap_IntInterval_overlapLength, METH_VARARGS, NULL},
	{ (char *)"IntInterval_overlapFraction", _wrap_IntInterval_overlapFraction, METH_VARARGS, NULL},
	{ (char *)"IntInterval_logicalDifference", _wrap_IntInterval_logicalDifference, METH_VARARGS, NULL},
	{ (char *)"delete_IntInterval", _wrap_delete_IntInterval, METH_VARARGS, NULL},
	{ (char *)"IntInterval_swigregister", IntInterval_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongInterval", _wrap_new_LLongInterval, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_setMin", _wrap_LLongInterval_setMin, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_setMax", _wrap_LLongInterval_setMax, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_setBounds", _wrap_LLongInterval_setBounds, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_min", _wrap_LLongInterval_min, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_max", _wrap_LLongInterval_max, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_getBounds", _wrap_LLongInterval_getBounds, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_length", _wrap_LLongInterval_length, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_midpoint", _wrap_LLongInterval_midpoint, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_isInsideLower", _wrap_LLongInterval_isInsideLower, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_isInsideUpper", _wrap_LLongInterval_isInsideUpper, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_isInsideWithBounds", _wrap_LLongInterval_isInsideWithBounds, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_isInside", _wrap_LLongInterval_isInside, METH_VARARGS, NULL},
	{ (char *)"LLongInterval___imul__", _wrap_LLongInterval___imul__, METH_VARARGS, NULL},
	{ (char *)"LLongInterval___itruediv__", _wrap_LLongInterval___itruediv__, METH_VARARGS, NULL},
	{ (char *)"LLongInterval___iadd__", _wrap_LLongInterval___iadd__, METH_VARARGS, NULL},
	{ (char *)"LLongInterval___isub__", _wrap_LLongInterval___isub__, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_moveMidpointTo0", _wrap_LLongInterval_moveMidpointTo0, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_expand", _wrap_LLongInterval_expand, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_overlap", _wrap_LLongInterval_overlap, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_overlapLength", _wrap_LLongInterval_overlapLength, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_overlapFraction", _wrap_LLongInterval_overlapFraction, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_logicalDifference", _wrap_LLongInterval_logicalDifference, METH_VARARGS, NULL},
	{ (char *)"delete_LLongInterval", _wrap_delete_LLongInterval, METH_VARARGS, NULL},
	{ (char *)"LLongInterval_swigregister", LLongInterval_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatInterval", _wrap_new_FloatInterval, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_setMin", _wrap_FloatInterval_setMin, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_setMax", _wrap_FloatInterval_setMax, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_setBounds", _wrap_FloatInterval_setBounds, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_min", _wrap_FloatInterval_min, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_max", _wrap_FloatInterval_max, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_getBounds", _wrap_FloatInterval_getBounds, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_length", _wrap_FloatInterval_length, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_midpoint", _wrap_FloatInterval_midpoint, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_isInsideLower", _wrap_FloatInterval_isInsideLower, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_isInsideUpper", _wrap_FloatInterval_isInsideUpper, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_isInsideWithBounds", _wrap_FloatInterval_isInsideWithBounds, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_isInside", _wrap_FloatInterval_isInside, METH_VARARGS, NULL},
	{ (char *)"FloatInterval___imul__", _wrap_FloatInterval___imul__, METH_VARARGS, NULL},
	{ (char *)"FloatInterval___itruediv__", _wrap_FloatInterval___itruediv__, METH_VARARGS, NULL},
	{ (char *)"FloatInterval___iadd__", _wrap_FloatInterval___iadd__, METH_VARARGS, NULL},
	{ (char *)"FloatInterval___isub__", _wrap_FloatInterval___isub__, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_moveMidpointTo0", _wrap_FloatInterval_moveMidpointTo0, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_expand", _wrap_FloatInterval_expand, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_overlap", _wrap_FloatInterval_overlap, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_overlapLength", _wrap_FloatInterval_overlapLength, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_overlapFraction", _wrap_FloatInterval_overlapFraction, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_logicalDifference", _wrap_FloatInterval_logicalDifference, METH_VARARGS, NULL},
	{ (char *)"delete_FloatInterval", _wrap_delete_FloatInterval, METH_VARARGS, NULL},
	{ (char *)"FloatInterval_swigregister", FloatInterval_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleInterval", _wrap_new_DoubleInterval, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_setMin", _wrap_DoubleInterval_setMin, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_setMax", _wrap_DoubleInterval_setMax, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_setBounds", _wrap_DoubleInterval_setBounds, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_min", _wrap_DoubleInterval_min, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_max", _wrap_DoubleInterval_max, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_getBounds", _wrap_DoubleInterval_getBounds, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_length", _wrap_DoubleInterval_length, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_midpoint", _wrap_DoubleInterval_midpoint, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_isInsideLower", _wrap_DoubleInterval_isInsideLower, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_isInsideUpper", _wrap_DoubleInterval_isInsideUpper, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_isInsideWithBounds", _wrap_DoubleInterval_isInsideWithBounds, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_isInside", _wrap_DoubleInterval_isInside, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval___imul__", _wrap_DoubleInterval___imul__, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval___itruediv__", _wrap_DoubleInterval___itruediv__, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval___iadd__", _wrap_DoubleInterval___iadd__, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval___isub__", _wrap_DoubleInterval___isub__, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_moveMidpointTo0", _wrap_DoubleInterval_moveMidpointTo0, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_expand", _wrap_DoubleInterval_expand, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_overlap", _wrap_DoubleInterval_overlap, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_overlapLength", _wrap_DoubleInterval_overlapLength, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_overlapFraction", _wrap_DoubleInterval_overlapFraction, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_logicalDifference", _wrap_DoubleInterval_logicalDifference, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleInterval", _wrap_delete_DoubleInterval, METH_VARARGS, NULL},
	{ (char *)"DoubleInterval_swigregister", DoubleInterval_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UIntInterval", _wrap_new_UIntInterval, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_setMin", _wrap_UIntInterval_setMin, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_setMax", _wrap_UIntInterval_setMax, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_setBounds", _wrap_UIntInterval_setBounds, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_min", _wrap_UIntInterval_min, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_max", _wrap_UIntInterval_max, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_getBounds", _wrap_UIntInterval_getBounds, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_length", _wrap_UIntInterval_length, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_midpoint", _wrap_UIntInterval_midpoint, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_isInsideLower", _wrap_UIntInterval_isInsideLower, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_isInsideUpper", _wrap_UIntInterval_isInsideUpper, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_isInsideWithBounds", _wrap_UIntInterval_isInsideWithBounds, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_isInside", _wrap_UIntInterval_isInside, METH_VARARGS, NULL},
	{ (char *)"UIntInterval___imul__", _wrap_UIntInterval___imul__, METH_VARARGS, NULL},
	{ (char *)"UIntInterval___itruediv__", _wrap_UIntInterval___itruediv__, METH_VARARGS, NULL},
	{ (char *)"UIntInterval___iadd__", _wrap_UIntInterval___iadd__, METH_VARARGS, NULL},
	{ (char *)"UIntInterval___isub__", _wrap_UIntInterval___isub__, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_moveMidpointTo0", _wrap_UIntInterval_moveMidpointTo0, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_expand", _wrap_UIntInterval_expand, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_overlap", _wrap_UIntInterval_overlap, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_overlapLength", _wrap_UIntInterval_overlapLength, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_overlapFraction", _wrap_UIntInterval_overlapFraction, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_logicalDifference", _wrap_UIntInterval_logicalDifference, METH_VARARGS, NULL},
	{ (char *)"delete_UIntInterval", _wrap_delete_UIntInterval, METH_VARARGS, NULL},
	{ (char *)"UIntInterval_swigregister", UIntInterval_swigregister, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_iterator", _wrap_IntIntervalVector_iterator, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector___nonzero__", _wrap_IntIntervalVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector___bool__", _wrap_IntIntervalVector___bool__, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector___len__", _wrap_IntIntervalVector___len__, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector___getslice__", _wrap_IntIntervalVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector___setslice__", _wrap_IntIntervalVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector___delslice__", _wrap_IntIntervalVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector___delitem__", _wrap_IntIntervalVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector___getitem__", _wrap_IntIntervalVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector___setitem__", _wrap_IntIntervalVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_pop", _wrap_IntIntervalVector_pop, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_append", _wrap_IntIntervalVector_append, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_empty", _wrap_IntIntervalVector_empty, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_size", _wrap_IntIntervalVector_size, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_swap", _wrap_IntIntervalVector_swap, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_begin", _wrap_IntIntervalVector_begin, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_end", _wrap_IntIntervalVector_end, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_rbegin", _wrap_IntIntervalVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_rend", _wrap_IntIntervalVector_rend, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_clear", _wrap_IntIntervalVector_clear, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_get_allocator", _wrap_IntIntervalVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_pop_back", _wrap_IntIntervalVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_erase", _wrap_IntIntervalVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_IntIntervalVector", _wrap_new_IntIntervalVector, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_push_back", _wrap_IntIntervalVector_push_back, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_front", _wrap_IntIntervalVector_front, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_back", _wrap_IntIntervalVector_back, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_assign", _wrap_IntIntervalVector_assign, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_resize", _wrap_IntIntervalVector_resize, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_insert", _wrap_IntIntervalVector_insert, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_reserve", _wrap_IntIntervalVector_reserve, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_capacity", _wrap_IntIntervalVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_IntIntervalVector", _wrap_delete_IntIntervalVector, METH_VARARGS, NULL},
	{ (char *)"IntIntervalVector_swigregister", IntIntervalVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_iterator", _wrap_UIntIntervalVector_iterator, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector___nonzero__", _wrap_UIntIntervalVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector___bool__", _wrap_UIntIntervalVector___bool__, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector___len__", _wrap_UIntIntervalVector___len__, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector___getslice__", _wrap_UIntIntervalVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector___setslice__", _wrap_UIntIntervalVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector___delslice__", _wrap_UIntIntervalVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector___delitem__", _wrap_UIntIntervalVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector___getitem__", _wrap_UIntIntervalVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector___setitem__", _wrap_UIntIntervalVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_pop", _wrap_UIntIntervalVector_pop, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_append", _wrap_UIntIntervalVector_append, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_empty", _wrap_UIntIntervalVector_empty, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_size", _wrap_UIntIntervalVector_size, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_swap", _wrap_UIntIntervalVector_swap, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_begin", _wrap_UIntIntervalVector_begin, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_end", _wrap_UIntIntervalVector_end, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_rbegin", _wrap_UIntIntervalVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_rend", _wrap_UIntIntervalVector_rend, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_clear", _wrap_UIntIntervalVector_clear, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_get_allocator", _wrap_UIntIntervalVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_pop_back", _wrap_UIntIntervalVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_erase", _wrap_UIntIntervalVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_UIntIntervalVector", _wrap_new_UIntIntervalVector, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_push_back", _wrap_UIntIntervalVector_push_back, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_front", _wrap_UIntIntervalVector_front, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_back", _wrap_UIntIntervalVector_back, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_assign", _wrap_UIntIntervalVector_assign, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_resize", _wrap_UIntIntervalVector_resize, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_insert", _wrap_UIntIntervalVector_insert, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_reserve", _wrap_UIntIntervalVector_reserve, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_capacity", _wrap_UIntIntervalVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_UIntIntervalVector", _wrap_delete_UIntIntervalVector, METH_VARARGS, NULL},
	{ (char *)"UIntIntervalVector_swigregister", UIntIntervalVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_iterator", _wrap_LLongIntervalVector_iterator, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector___nonzero__", _wrap_LLongIntervalVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector___bool__", _wrap_LLongIntervalVector___bool__, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector___len__", _wrap_LLongIntervalVector___len__, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector___getslice__", _wrap_LLongIntervalVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector___setslice__", _wrap_LLongIntervalVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector___delslice__", _wrap_LLongIntervalVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector___delitem__", _wrap_LLongIntervalVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector___getitem__", _wrap_LLongIntervalVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector___setitem__", _wrap_LLongIntervalVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_pop", _wrap_LLongIntervalVector_pop, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_append", _wrap_LLongIntervalVector_append, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_empty", _wrap_LLongIntervalVector_empty, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_size", _wrap_LLongIntervalVector_size, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_swap", _wrap_LLongIntervalVector_swap, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_begin", _wrap_LLongIntervalVector_begin, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_end", _wrap_LLongIntervalVector_end, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_rbegin", _wrap_LLongIntervalVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_rend", _wrap_LLongIntervalVector_rend, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_clear", _wrap_LLongIntervalVector_clear, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_get_allocator", _wrap_LLongIntervalVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_pop_back", _wrap_LLongIntervalVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_erase", _wrap_LLongIntervalVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_LLongIntervalVector", _wrap_new_LLongIntervalVector, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_push_back", _wrap_LLongIntervalVector_push_back, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_front", _wrap_LLongIntervalVector_front, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_back", _wrap_LLongIntervalVector_back, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_assign", _wrap_LLongIntervalVector_assign, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_resize", _wrap_LLongIntervalVector_resize, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_insert", _wrap_LLongIntervalVector_insert, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_reserve", _wrap_LLongIntervalVector_reserve, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_capacity", _wrap_LLongIntervalVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_LLongIntervalVector", _wrap_delete_LLongIntervalVector, METH_VARARGS, NULL},
	{ (char *)"LLongIntervalVector_swigregister", LLongIntervalVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_iterator", _wrap_FloatIntervalVector_iterator, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector___nonzero__", _wrap_FloatIntervalVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector___bool__", _wrap_FloatIntervalVector___bool__, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector___len__", _wrap_FloatIntervalVector___len__, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector___getslice__", _wrap_FloatIntervalVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector___setslice__", _wrap_FloatIntervalVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector___delslice__", _wrap_FloatIntervalVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector___delitem__", _wrap_FloatIntervalVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector___getitem__", _wrap_FloatIntervalVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector___setitem__", _wrap_FloatIntervalVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_pop", _wrap_FloatIntervalVector_pop, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_append", _wrap_FloatIntervalVector_append, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_empty", _wrap_FloatIntervalVector_empty, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_size", _wrap_FloatIntervalVector_size, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_swap", _wrap_FloatIntervalVector_swap, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_begin", _wrap_FloatIntervalVector_begin, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_end", _wrap_FloatIntervalVector_end, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_rbegin", _wrap_FloatIntervalVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_rend", _wrap_FloatIntervalVector_rend, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_clear", _wrap_FloatIntervalVector_clear, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_get_allocator", _wrap_FloatIntervalVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_pop_back", _wrap_FloatIntervalVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_erase", _wrap_FloatIntervalVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_FloatIntervalVector", _wrap_new_FloatIntervalVector, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_push_back", _wrap_FloatIntervalVector_push_back, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_front", _wrap_FloatIntervalVector_front, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_back", _wrap_FloatIntervalVector_back, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_assign", _wrap_FloatIntervalVector_assign, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_resize", _wrap_FloatIntervalVector_resize, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_insert", _wrap_FloatIntervalVector_insert, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_reserve", _wrap_FloatIntervalVector_reserve, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_capacity", _wrap_FloatIntervalVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_FloatIntervalVector", _wrap_delete_FloatIntervalVector, METH_VARARGS, NULL},
	{ (char *)"FloatIntervalVector_swigregister", FloatIntervalVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_iterator", _wrap_DoubleIntervalVector_iterator, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector___nonzero__", _wrap_DoubleIntervalVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector___bool__", _wrap_DoubleIntervalVector___bool__, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector___len__", _wrap_DoubleIntervalVector___len__, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector___getslice__", _wrap_DoubleIntervalVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector___setslice__", _wrap_DoubleIntervalVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector___delslice__", _wrap_DoubleIntervalVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector___delitem__", _wrap_DoubleIntervalVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector___getitem__", _wrap_DoubleIntervalVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector___setitem__", _wrap_DoubleIntervalVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_pop", _wrap_DoubleIntervalVector_pop, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_append", _wrap_DoubleIntervalVector_append, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_empty", _wrap_DoubleIntervalVector_empty, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_size", _wrap_DoubleIntervalVector_size, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_swap", _wrap_DoubleIntervalVector_swap, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_begin", _wrap_DoubleIntervalVector_begin, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_end", _wrap_DoubleIntervalVector_end, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_rbegin", _wrap_DoubleIntervalVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_rend", _wrap_DoubleIntervalVector_rend, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_clear", _wrap_DoubleIntervalVector_clear, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_get_allocator", _wrap_DoubleIntervalVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_pop_back", _wrap_DoubleIntervalVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_erase", _wrap_DoubleIntervalVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_DoubleIntervalVector", _wrap_new_DoubleIntervalVector, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_push_back", _wrap_DoubleIntervalVector_push_back, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_front", _wrap_DoubleIntervalVector_front, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_back", _wrap_DoubleIntervalVector_back, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_assign", _wrap_DoubleIntervalVector_assign, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_resize", _wrap_DoubleIntervalVector_resize, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_insert", _wrap_DoubleIntervalVector_insert, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_reserve", _wrap_DoubleIntervalVector_reserve, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_capacity", _wrap_DoubleIntervalVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleIntervalVector", _wrap_delete_DoubleIntervalVector, METH_VARARGS, NULL},
	{ (char *)"DoubleIntervalVector_swigregister", DoubleIntervalVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_iterator", _wrap_UCharIntervalVector_iterator, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector___nonzero__", _wrap_UCharIntervalVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector___bool__", _wrap_UCharIntervalVector___bool__, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector___len__", _wrap_UCharIntervalVector___len__, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector___getslice__", _wrap_UCharIntervalVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector___setslice__", _wrap_UCharIntervalVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector___delslice__", _wrap_UCharIntervalVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector___delitem__", _wrap_UCharIntervalVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector___getitem__", _wrap_UCharIntervalVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector___setitem__", _wrap_UCharIntervalVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_pop", _wrap_UCharIntervalVector_pop, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_append", _wrap_UCharIntervalVector_append, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_empty", _wrap_UCharIntervalVector_empty, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_size", _wrap_UCharIntervalVector_size, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_swap", _wrap_UCharIntervalVector_swap, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_begin", _wrap_UCharIntervalVector_begin, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_end", _wrap_UCharIntervalVector_end, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_rbegin", _wrap_UCharIntervalVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_rend", _wrap_UCharIntervalVector_rend, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_clear", _wrap_UCharIntervalVector_clear, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_get_allocator", _wrap_UCharIntervalVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_pop_back", _wrap_UCharIntervalVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_erase", _wrap_UCharIntervalVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_UCharIntervalVector", _wrap_new_UCharIntervalVector, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_push_back", _wrap_UCharIntervalVector_push_back, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_front", _wrap_UCharIntervalVector_front, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_back", _wrap_UCharIntervalVector_back, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_assign", _wrap_UCharIntervalVector_assign, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_resize", _wrap_UCharIntervalVector_resize, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_insert", _wrap_UCharIntervalVector_insert, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_reserve", _wrap_UCharIntervalVector_reserve, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_capacity", _wrap_UCharIntervalVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_UCharIntervalVector", _wrap_delete_UCharIntervalVector, METH_VARARGS, NULL},
	{ (char *)"UCharIntervalVector_swigregister", UCharIntervalVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharBoxND", _wrap_new_UCharBoxND, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND_dim", _wrap_UCharBoxND_dim, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND_volume", _wrap_UCharBoxND_volume, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND_getMidpoint", _wrap_UCharBoxND_getMidpoint, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND___imul__", _wrap_UCharBoxND___imul__, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND___itruediv__", _wrap_UCharBoxND___itruediv__, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND_expand", _wrap_UCharBoxND_expand, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND_moveToOrigin", _wrap_UCharBoxND_moveToOrigin, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND_overlapVolume", _wrap_UCharBoxND_overlapVolume, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND_overlapFraction", _wrap_UCharBoxND_overlapFraction, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND_unitBox", _wrap_UCharBoxND_unitBox, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND_sizeTwoBox", _wrap_UCharBoxND_sizeTwoBox, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND_allSpace", _wrap_UCharBoxND_allSpace, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND_classId", _wrap_UCharBoxND_classId, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND_write", _wrap_UCharBoxND_write, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND_classname", _wrap_UCharBoxND_classname, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND_version", _wrap_UCharBoxND_version, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND_restore", _wrap_UCharBoxND_restore, METH_VARARGS, NULL},
	{ (char *)"delete_UCharBoxND", _wrap_delete_UCharBoxND, METH_VARARGS, NULL},
	{ (char *)"UCharBoxND_swigregister", UCharBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_UCharBoxND", _wrap_new_ArchiveRecord_UCharBoxND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_UCharBoxND", _wrap_delete_ArchiveRecord_UCharBoxND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_UCharBoxND_swigregister", ArchiveRecord_UCharBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_UCharBoxND", _wrap_new_Ref_UCharBoxND, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharBoxND_restore", _wrap_Ref_UCharBoxND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharBoxND_retrieve", _wrap_Ref_UCharBoxND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharBoxND_getValue", _wrap_Ref_UCharBoxND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_UCharBoxND", _wrap_delete_Ref_UCharBoxND, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharBoxND_swigregister", Ref_UCharBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntBoxND", _wrap_new_IntBoxND, METH_VARARGS, NULL},
	{ (char *)"IntBoxND_dim", _wrap_IntBoxND_dim, METH_VARARGS, NULL},
	{ (char *)"IntBoxND_volume", _wrap_IntBoxND_volume, METH_VARARGS, NULL},
	{ (char *)"IntBoxND_getMidpoint", _wrap_IntBoxND_getMidpoint, METH_VARARGS, NULL},
	{ (char *)"IntBoxND___imul__", _wrap_IntBoxND___imul__, METH_VARARGS, NULL},
	{ (char *)"IntBoxND___itruediv__", _wrap_IntBoxND___itruediv__, METH_VARARGS, NULL},
	{ (char *)"IntBoxND_expand", _wrap_IntBoxND_expand, METH_VARARGS, NULL},
	{ (char *)"IntBoxND_moveToOrigin", _wrap_IntBoxND_moveToOrigin, METH_VARARGS, NULL},
	{ (char *)"IntBoxND_overlapVolume", _wrap_IntBoxND_overlapVolume, METH_VARARGS, NULL},
	{ (char *)"IntBoxND_overlapFraction", _wrap_IntBoxND_overlapFraction, METH_VARARGS, NULL},
	{ (char *)"IntBoxND_unitBox", _wrap_IntBoxND_unitBox, METH_VARARGS, NULL},
	{ (char *)"IntBoxND_sizeTwoBox", _wrap_IntBoxND_sizeTwoBox, METH_VARARGS, NULL},
	{ (char *)"IntBoxND_allSpace", _wrap_IntBoxND_allSpace, METH_VARARGS, NULL},
	{ (char *)"IntBoxND_classId", _wrap_IntBoxND_classId, METH_VARARGS, NULL},
	{ (char *)"IntBoxND_write", _wrap_IntBoxND_write, METH_VARARGS, NULL},
	{ (char *)"IntBoxND_classname", _wrap_IntBoxND_classname, METH_VARARGS, NULL},
	{ (char *)"IntBoxND_version", _wrap_IntBoxND_version, METH_VARARGS, NULL},
	{ (char *)"IntBoxND_restore", _wrap_IntBoxND_restore, METH_VARARGS, NULL},
	{ (char *)"delete_IntBoxND", _wrap_delete_IntBoxND, METH_VARARGS, NULL},
	{ (char *)"IntBoxND_swigregister", IntBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_IntBoxND", _wrap_new_ArchiveRecord_IntBoxND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_IntBoxND", _wrap_delete_ArchiveRecord_IntBoxND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_IntBoxND_swigregister", ArchiveRecord_IntBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_IntBoxND", _wrap_new_Ref_IntBoxND, METH_VARARGS, NULL},
	{ (char *)"Ref_IntBoxND_restore", _wrap_Ref_IntBoxND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_IntBoxND_retrieve", _wrap_Ref_IntBoxND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_IntBoxND_getValue", _wrap_Ref_IntBoxND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_IntBoxND", _wrap_delete_Ref_IntBoxND, METH_VARARGS, NULL},
	{ (char *)"Ref_IntBoxND_swigregister", Ref_IntBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongBoxND", _wrap_new_LLongBoxND, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND_dim", _wrap_LLongBoxND_dim, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND_volume", _wrap_LLongBoxND_volume, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND_getMidpoint", _wrap_LLongBoxND_getMidpoint, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND___imul__", _wrap_LLongBoxND___imul__, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND___itruediv__", _wrap_LLongBoxND___itruediv__, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND_expand", _wrap_LLongBoxND_expand, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND_moveToOrigin", _wrap_LLongBoxND_moveToOrigin, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND_overlapVolume", _wrap_LLongBoxND_overlapVolume, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND_overlapFraction", _wrap_LLongBoxND_overlapFraction, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND_unitBox", _wrap_LLongBoxND_unitBox, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND_sizeTwoBox", _wrap_LLongBoxND_sizeTwoBox, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND_allSpace", _wrap_LLongBoxND_allSpace, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND_classId", _wrap_LLongBoxND_classId, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND_write", _wrap_LLongBoxND_write, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND_classname", _wrap_LLongBoxND_classname, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND_version", _wrap_LLongBoxND_version, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND_restore", _wrap_LLongBoxND_restore, METH_VARARGS, NULL},
	{ (char *)"delete_LLongBoxND", _wrap_delete_LLongBoxND, METH_VARARGS, NULL},
	{ (char *)"LLongBoxND_swigregister", LLongBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_LLongBoxND", _wrap_new_ArchiveRecord_LLongBoxND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_LLongBoxND", _wrap_delete_ArchiveRecord_LLongBoxND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_LLongBoxND_swigregister", ArchiveRecord_LLongBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_LLongBoxND", _wrap_new_Ref_LLongBoxND, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongBoxND_restore", _wrap_Ref_LLongBoxND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongBoxND_retrieve", _wrap_Ref_LLongBoxND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongBoxND_getValue", _wrap_Ref_LLongBoxND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_LLongBoxND", _wrap_delete_Ref_LLongBoxND, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongBoxND_swigregister", Ref_LLongBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatBoxND", _wrap_new_FloatBoxND, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND_dim", _wrap_FloatBoxND_dim, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND_volume", _wrap_FloatBoxND_volume, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND_getMidpoint", _wrap_FloatBoxND_getMidpoint, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND___imul__", _wrap_FloatBoxND___imul__, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND___itruediv__", _wrap_FloatBoxND___itruediv__, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND_expand", _wrap_FloatBoxND_expand, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND_moveToOrigin", _wrap_FloatBoxND_moveToOrigin, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND_overlapVolume", _wrap_FloatBoxND_overlapVolume, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND_overlapFraction", _wrap_FloatBoxND_overlapFraction, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND_unitBox", _wrap_FloatBoxND_unitBox, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND_sizeTwoBox", _wrap_FloatBoxND_sizeTwoBox, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND_allSpace", _wrap_FloatBoxND_allSpace, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND_classId", _wrap_FloatBoxND_classId, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND_write", _wrap_FloatBoxND_write, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND_classname", _wrap_FloatBoxND_classname, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND_version", _wrap_FloatBoxND_version, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND_restore", _wrap_FloatBoxND_restore, METH_VARARGS, NULL},
	{ (char *)"delete_FloatBoxND", _wrap_delete_FloatBoxND, METH_VARARGS, NULL},
	{ (char *)"FloatBoxND_swigregister", FloatBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_FloatBoxND", _wrap_new_ArchiveRecord_FloatBoxND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_FloatBoxND", _wrap_delete_ArchiveRecord_FloatBoxND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_FloatBoxND_swigregister", ArchiveRecord_FloatBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_FloatBoxND", _wrap_new_Ref_FloatBoxND, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatBoxND_restore", _wrap_Ref_FloatBoxND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatBoxND_retrieve", _wrap_Ref_FloatBoxND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatBoxND_getValue", _wrap_Ref_FloatBoxND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_FloatBoxND", _wrap_delete_Ref_FloatBoxND, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatBoxND_swigregister", Ref_FloatBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleBoxND", _wrap_new_DoubleBoxND, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND_dim", _wrap_DoubleBoxND_dim, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND_volume", _wrap_DoubleBoxND_volume, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND_getMidpoint", _wrap_DoubleBoxND_getMidpoint, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND___imul__", _wrap_DoubleBoxND___imul__, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND___itruediv__", _wrap_DoubleBoxND___itruediv__, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND_expand", _wrap_DoubleBoxND_expand, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND_moveToOrigin", _wrap_DoubleBoxND_moveToOrigin, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND_overlapVolume", _wrap_DoubleBoxND_overlapVolume, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND_overlapFraction", _wrap_DoubleBoxND_overlapFraction, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND_unitBox", _wrap_DoubleBoxND_unitBox, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND_sizeTwoBox", _wrap_DoubleBoxND_sizeTwoBox, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND_allSpace", _wrap_DoubleBoxND_allSpace, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND_classId", _wrap_DoubleBoxND_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND_write", _wrap_DoubleBoxND_write, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND_classname", _wrap_DoubleBoxND_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND_version", _wrap_DoubleBoxND_version, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND_restore", _wrap_DoubleBoxND_restore, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleBoxND", _wrap_delete_DoubleBoxND, METH_VARARGS, NULL},
	{ (char *)"DoubleBoxND_swigregister", DoubleBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DoubleBoxND", _wrap_new_ArchiveRecord_DoubleBoxND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DoubleBoxND", _wrap_delete_ArchiveRecord_DoubleBoxND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DoubleBoxND_swigregister", ArchiveRecord_DoubleBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DoubleBoxND", _wrap_new_Ref_DoubleBoxND, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleBoxND_restore", _wrap_Ref_DoubleBoxND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleBoxND_retrieve", _wrap_Ref_DoubleBoxND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleBoxND_getValue", _wrap_Ref_DoubleBoxND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DoubleBoxND", _wrap_delete_Ref_DoubleBoxND, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleBoxND_swigregister", Ref_DoubleBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UIntBoxND", _wrap_new_UIntBoxND, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND_dim", _wrap_UIntBoxND_dim, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND_volume", _wrap_UIntBoxND_volume, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND_getMidpoint", _wrap_UIntBoxND_getMidpoint, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND___imul__", _wrap_UIntBoxND___imul__, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND___itruediv__", _wrap_UIntBoxND___itruediv__, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND_expand", _wrap_UIntBoxND_expand, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND_moveToOrigin", _wrap_UIntBoxND_moveToOrigin, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND_overlapVolume", _wrap_UIntBoxND_overlapVolume, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND_overlapFraction", _wrap_UIntBoxND_overlapFraction, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND_unitBox", _wrap_UIntBoxND_unitBox, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND_sizeTwoBox", _wrap_UIntBoxND_sizeTwoBox, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND_allSpace", _wrap_UIntBoxND_allSpace, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND_classId", _wrap_UIntBoxND_classId, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND_write", _wrap_UIntBoxND_write, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND_classname", _wrap_UIntBoxND_classname, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND_version", _wrap_UIntBoxND_version, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND_restore", _wrap_UIntBoxND_restore, METH_VARARGS, NULL},
	{ (char *)"delete_UIntBoxND", _wrap_delete_UIntBoxND, METH_VARARGS, NULL},
	{ (char *)"UIntBoxND_swigregister", UIntBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_UIntBoxND", _wrap_new_ArchiveRecord_UIntBoxND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_UIntBoxND", _wrap_delete_ArchiveRecord_UIntBoxND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_UIntBoxND_swigregister", ArchiveRecord_UIntBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_UIntBoxND", _wrap_new_Ref_UIntBoxND, METH_VARARGS, NULL},
	{ (char *)"Ref_UIntBoxND_restore", _wrap_Ref_UIntBoxND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_UIntBoxND_retrieve", _wrap_Ref_UIntBoxND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_UIntBoxND_getValue", _wrap_Ref_UIntBoxND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_UIntBoxND", _wrap_delete_Ref_UIntBoxND, METH_VARARGS, NULL},
	{ (char *)"Ref_UIntBoxND_swigregister", Ref_UIntBoxND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArrayRange", _wrap_new_ArrayRange, METH_VARARGS, NULL},
	{ (char *)"ArrayRange_shape", _wrap_ArrayRange_shape, METH_VARARGS, NULL},
	{ (char *)"ArrayRange_isCompatible", _wrap_ArrayRange_isCompatible, METH_VARARGS, NULL},
	{ (char *)"ArrayRange_rangeSize", _wrap_ArrayRange_rangeSize, METH_VARARGS, NULL},
	{ (char *)"ArrayRange___lt__", _wrap_ArrayRange___lt__, METH_VARARGS, NULL},
	{ (char *)"ArrayRange_stripOuterLayer", _wrap_ArrayRange_stripOuterLayer, METH_VARARGS, NULL},
	{ (char *)"ArrayRange_lowerLimits", _wrap_ArrayRange_lowerLimits, METH_VARARGS, NULL},
	{ (char *)"ArrayRange_upperLimits", _wrap_ArrayRange_upperLimits, METH_VARARGS, NULL},
	{ (char *)"ArrayRange_rangeLength", _wrap_ArrayRange_rangeLength, METH_VARARGS, NULL},
	{ (char *)"ArrayRange_classId", _wrap_ArrayRange_classId, METH_VARARGS, NULL},
	{ (char *)"ArrayRange_write", _wrap_ArrayRange_write, METH_VARARGS, NULL},
	{ (char *)"ArrayRange_classname", _wrap_ArrayRange_classname, METH_VARARGS, NULL},
	{ (char *)"ArrayRange_version", _wrap_ArrayRange_version, METH_VARARGS, NULL},
	{ (char *)"ArrayRange_restore", _wrap_ArrayRange_restore, METH_VARARGS, NULL},
	{ (char *)"delete_ArrayRange", _wrap_delete_ArrayRange, METH_VARARGS, NULL},
	{ (char *)"ArrayRange_swigregister", ArrayRange_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_StatAccumulator", _wrap_new_StatAccumulator, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_count", _wrap_StatAccumulator_count, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_min", _wrap_StatAccumulator_min, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_max", _wrap_StatAccumulator_max, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_sum", _wrap_StatAccumulator_sum, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_sumsq", _wrap_StatAccumulator_sumsq, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_mean", _wrap_StatAccumulator_mean, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_stdev", _wrap_StatAccumulator_stdev, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_meanUncertainty", _wrap_StatAccumulator_meanUncertainty, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_location", _wrap_StatAccumulator_location, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_rangeDown", _wrap_StatAccumulator_rangeDown, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_rangeUp", _wrap_StatAccumulator_rangeUp, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_noThrowMean", _wrap_StatAccumulator_noThrowMean, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_noThrowStdev", _wrap_StatAccumulator_noThrowStdev, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_noThrowMeanUncertainty", _wrap_StatAccumulator_noThrowMeanUncertainty, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator___iadd__", _wrap_StatAccumulator___iadd__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_accumulate", _wrap_StatAccumulator_accumulate, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator___add__", _wrap_StatAccumulator___add__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_reset", _wrap_StatAccumulator_reset, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator___eq__", _wrap_StatAccumulator___eq__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator___ne__", _wrap_StatAccumulator___ne__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_classId", _wrap_StatAccumulator_classId, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_write", _wrap_StatAccumulator_write, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_classname", _wrap_StatAccumulator_classname, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_version", _wrap_StatAccumulator_version, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_restore", _wrap_StatAccumulator_restore, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator___mul__", _wrap_StatAccumulator___mul__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator___div__", _wrap_StatAccumulator___div__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator___imul__", _wrap_StatAccumulator___imul__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator___idiv__", _wrap_StatAccumulator___idiv__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_accumulateAll", _wrap_StatAccumulator_accumulateAll, METH_VARARGS, NULL},
	{ (char *)"delete_StatAccumulator", _wrap_delete_StatAccumulator, METH_VARARGS, NULL},
	{ (char *)"StatAccumulator_swigregister", StatAccumulator_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_WeightedStatAccumulator", _wrap_new_WeightedStatAccumulator, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_min", _wrap_WeightedStatAccumulator_min, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_max", _wrap_WeightedStatAccumulator_max, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_maxWeight", _wrap_WeightedStatAccumulator_maxWeight, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_mean", _wrap_WeightedStatAccumulator_mean, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_stdev", _wrap_WeightedStatAccumulator_stdev, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_meanUncertainty", _wrap_WeightedStatAccumulator_meanUncertainty, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_location", _wrap_WeightedStatAccumulator_location, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_rangeDown", _wrap_WeightedStatAccumulator_rangeDown, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_rangeUp", _wrap_WeightedStatAccumulator_rangeUp, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_noThrowMean", _wrap_WeightedStatAccumulator_noThrowMean, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_noThrowStdev", _wrap_WeightedStatAccumulator_noThrowStdev, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_noThrowMeanUncertainty", _wrap_WeightedStatAccumulator_noThrowMeanUncertainty, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_count", _wrap_WeightedStatAccumulator_count, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_ncalls", _wrap_WeightedStatAccumulator_ncalls, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_nfills", _wrap_WeightedStatAccumulator_nfills, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_averageWeight", _wrap_WeightedStatAccumulator_averageWeight, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_sumOfWeights", _wrap_WeightedStatAccumulator_sumOfWeights, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_accumulate", _wrap_WeightedStatAccumulator_accumulate, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator___add__", _wrap_WeightedStatAccumulator___add__, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_scaleWeights", _wrap_WeightedStatAccumulator_scaleWeights, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_reset", _wrap_WeightedStatAccumulator_reset, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator___eq__", _wrap_WeightedStatAccumulator___eq__, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator___ne__", _wrap_WeightedStatAccumulator___ne__, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_classId", _wrap_WeightedStatAccumulator_classId, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_write", _wrap_WeightedStatAccumulator_write, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_classname", _wrap_WeightedStatAccumulator_classname, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_version", _wrap_WeightedStatAccumulator_version, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_restore", _wrap_WeightedStatAccumulator_restore, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator___mul__", _wrap_WeightedStatAccumulator___mul__, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator___div__", _wrap_WeightedStatAccumulator___div__, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator___imul__", _wrap_WeightedStatAccumulator___imul__, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator___idiv__", _wrap_WeightedStatAccumulator___idiv__, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator___iadd__", _wrap_WeightedStatAccumulator___iadd__, METH_VARARGS, NULL},
	{ (char *)"delete_WeightedStatAccumulator", _wrap_delete_WeightedStatAccumulator, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulator_swigregister", WeightedStatAccumulator_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatWeightedSampleAccumulator", _wrap_new_FloatWeightedSampleAccumulator, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_maxWeight", _wrap_FloatWeightedSampleAccumulator_maxWeight, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_ncalls", _wrap_FloatWeightedSampleAccumulator_ncalls, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_nfills", _wrap_FloatWeightedSampleAccumulator_nfills, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_count", _wrap_FloatWeightedSampleAccumulator_count, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_min", _wrap_FloatWeightedSampleAccumulator_min, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_max", _wrap_FloatWeightedSampleAccumulator_max, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_mean", _wrap_FloatWeightedSampleAccumulator_mean, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_stdev", _wrap_FloatWeightedSampleAccumulator_stdev, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_meanUncertainty", _wrap_FloatWeightedSampleAccumulator_meanUncertainty, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_median", _wrap_FloatWeightedSampleAccumulator_median, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_cdf", _wrap_FloatWeightedSampleAccumulator_cdf, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_weightBelow", _wrap_FloatWeightedSampleAccumulator_weightBelow, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_quantile", _wrap_FloatWeightedSampleAccumulator_quantile, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_location", _wrap_FloatWeightedSampleAccumulator_location, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_rangeDown", _wrap_FloatWeightedSampleAccumulator_rangeDown, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_rangeUp", _wrap_FloatWeightedSampleAccumulator_rangeUp, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_noThrowMean", _wrap_FloatWeightedSampleAccumulator_noThrowMean, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_noThrowStdev", _wrap_FloatWeightedSampleAccumulator_noThrowStdev, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_noThrowMeanUncertainty", _wrap_FloatWeightedSampleAccumulator_noThrowMeanUncertainty, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_averageWeight", _wrap_FloatWeightedSampleAccumulator_averageWeight, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_sumOfWeights", _wrap_FloatWeightedSampleAccumulator_sumOfWeights, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_data", _wrap_FloatWeightedSampleAccumulator_data, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator___eq__", _wrap_FloatWeightedSampleAccumulator___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator___ne__", _wrap_FloatWeightedSampleAccumulator___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator___add__", _wrap_FloatWeightedSampleAccumulator___add__, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_scaleWeights", _wrap_FloatWeightedSampleAccumulator_scaleWeights, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_reset", _wrap_FloatWeightedSampleAccumulator_reset, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_reserve", _wrap_FloatWeightedSampleAccumulator_reserve, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_classId", _wrap_FloatWeightedSampleAccumulator_classId, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_write", _wrap_FloatWeightedSampleAccumulator_write, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_classname", _wrap_FloatWeightedSampleAccumulator_classname, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_version", _wrap_FloatWeightedSampleAccumulator_version, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_restore", _wrap_FloatWeightedSampleAccumulator_restore, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator___mul__", _wrap_FloatWeightedSampleAccumulator___mul__, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator___div__", _wrap_FloatWeightedSampleAccumulator___div__, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator___imul__", _wrap_FloatWeightedSampleAccumulator___imul__, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator___idiv__", _wrap_FloatWeightedSampleAccumulator___idiv__, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator___iadd__", _wrap_FloatWeightedSampleAccumulator___iadd__, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_accumulate", _wrap_FloatWeightedSampleAccumulator_accumulate, METH_VARARGS, NULL},
	{ (char *)"delete_FloatWeightedSampleAccumulator", _wrap_delete_FloatWeightedSampleAccumulator, METH_VARARGS, NULL},
	{ (char *)"FloatWeightedSampleAccumulator_swigregister", FloatWeightedSampleAccumulator_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleWeightedSampleAccumulator", _wrap_new_DoubleWeightedSampleAccumulator, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_maxWeight", _wrap_DoubleWeightedSampleAccumulator_maxWeight, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_ncalls", _wrap_DoubleWeightedSampleAccumulator_ncalls, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_nfills", _wrap_DoubleWeightedSampleAccumulator_nfills, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_count", _wrap_DoubleWeightedSampleAccumulator_count, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_min", _wrap_DoubleWeightedSampleAccumulator_min, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_max", _wrap_DoubleWeightedSampleAccumulator_max, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_mean", _wrap_DoubleWeightedSampleAccumulator_mean, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_stdev", _wrap_DoubleWeightedSampleAccumulator_stdev, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_meanUncertainty", _wrap_DoubleWeightedSampleAccumulator_meanUncertainty, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_median", _wrap_DoubleWeightedSampleAccumulator_median, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_cdf", _wrap_DoubleWeightedSampleAccumulator_cdf, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_weightBelow", _wrap_DoubleWeightedSampleAccumulator_weightBelow, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_quantile", _wrap_DoubleWeightedSampleAccumulator_quantile, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_location", _wrap_DoubleWeightedSampleAccumulator_location, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_rangeDown", _wrap_DoubleWeightedSampleAccumulator_rangeDown, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_rangeUp", _wrap_DoubleWeightedSampleAccumulator_rangeUp, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_noThrowMean", _wrap_DoubleWeightedSampleAccumulator_noThrowMean, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_noThrowStdev", _wrap_DoubleWeightedSampleAccumulator_noThrowStdev, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_noThrowMeanUncertainty", _wrap_DoubleWeightedSampleAccumulator_noThrowMeanUncertainty, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_averageWeight", _wrap_DoubleWeightedSampleAccumulator_averageWeight, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_sumOfWeights", _wrap_DoubleWeightedSampleAccumulator_sumOfWeights, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_data", _wrap_DoubleWeightedSampleAccumulator_data, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator___eq__", _wrap_DoubleWeightedSampleAccumulator___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator___ne__", _wrap_DoubleWeightedSampleAccumulator___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator___add__", _wrap_DoubleWeightedSampleAccumulator___add__, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_scaleWeights", _wrap_DoubleWeightedSampleAccumulator_scaleWeights, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_reset", _wrap_DoubleWeightedSampleAccumulator_reset, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_reserve", _wrap_DoubleWeightedSampleAccumulator_reserve, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_classId", _wrap_DoubleWeightedSampleAccumulator_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_write", _wrap_DoubleWeightedSampleAccumulator_write, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_classname", _wrap_DoubleWeightedSampleAccumulator_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_version", _wrap_DoubleWeightedSampleAccumulator_version, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_restore", _wrap_DoubleWeightedSampleAccumulator_restore, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator___mul__", _wrap_DoubleWeightedSampleAccumulator___mul__, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator___div__", _wrap_DoubleWeightedSampleAccumulator___div__, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator___imul__", _wrap_DoubleWeightedSampleAccumulator___imul__, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator___idiv__", _wrap_DoubleWeightedSampleAccumulator___idiv__, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator___iadd__", _wrap_DoubleWeightedSampleAccumulator___iadd__, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_accumulate", _wrap_DoubleWeightedSampleAccumulator_accumulate, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleWeightedSampleAccumulator", _wrap_delete_DoubleWeightedSampleAccumulator, METH_VARARGS, NULL},
	{ (char *)"DoubleWeightedSampleAccumulator_swigregister", DoubleWeightedSampleAccumulator_swigregister, METH_VARARGS, NULL},
	{ (char *)"BinSummary_location", _wrap_BinSummary_location, METH_VARARGS, NULL},
	{ (char *)"BinSummary_rangeDown", _wrap_BinSummary_rangeDown, METH_VARARGS, NULL},
	{ (char *)"BinSummary_rangeUp", _wrap_BinSummary_rangeUp, METH_VARARGS, NULL},
	{ (char *)"BinSummary_stdev", _wrap_BinSummary_stdev, METH_VARARGS, NULL},
	{ (char *)"BinSummary_min", _wrap_BinSummary_min, METH_VARARGS, NULL},
	{ (char *)"BinSummary_max", _wrap_BinSummary_max, METH_VARARGS, NULL},
	{ (char *)"BinSummary_noThrowStdev", _wrap_BinSummary_noThrowStdev, METH_VARARGS, NULL},
	{ (char *)"BinSummary_noThrowMin", _wrap_BinSummary_noThrowMin, METH_VARARGS, NULL},
	{ (char *)"BinSummary_noThrowMax", _wrap_BinSummary_noThrowMax, METH_VARARGS, NULL},
	{ (char *)"BinSummary_hasStdev", _wrap_BinSummary_hasStdev, METH_VARARGS, NULL},
	{ (char *)"BinSummary_hasMin", _wrap_BinSummary_hasMin, METH_VARARGS, NULL},
	{ (char *)"BinSummary_hasMax", _wrap_BinSummary_hasMax, METH_VARARGS, NULL},
	{ (char *)"BinSummary_hasLimits", _wrap_BinSummary_hasLimits, METH_VARARGS, NULL},
	{ (char *)"BinSummary_setLocation", _wrap_BinSummary_setLocation, METH_VARARGS, NULL},
	{ (char *)"BinSummary_setStdev", _wrap_BinSummary_setStdev, METH_VARARGS, NULL},
	{ (char *)"BinSummary_setRangeDown", _wrap_BinSummary_setRangeDown, METH_VARARGS, NULL},
	{ (char *)"BinSummary_setRangeUp", _wrap_BinSummary_setRangeUp, METH_VARARGS, NULL},
	{ (char *)"BinSummary_setRanges", _wrap_BinSummary_setRanges, METH_VARARGS, NULL},
	{ (char *)"BinSummary_setMin", _wrap_BinSummary_setMin, METH_VARARGS, NULL},
	{ (char *)"BinSummary_setMax", _wrap_BinSummary_setMax, METH_VARARGS, NULL},
	{ (char *)"BinSummary_setLimits", _wrap_BinSummary_setLimits, METH_VARARGS, NULL},
	{ (char *)"BinSummary_setLocationAndLimits", _wrap_BinSummary_setLocationAndLimits, METH_VARARGS, NULL},
	{ (char *)"BinSummary_shift", _wrap_BinSummary_shift, METH_VARARGS, NULL},
	{ (char *)"BinSummary_scaleWidth", _wrap_BinSummary_scaleWidth, METH_VARARGS, NULL},
	{ (char *)"BinSummary_symmetrizeRanges", _wrap_BinSummary_symmetrizeRanges, METH_VARARGS, NULL},
	{ (char *)"BinSummary___imul__", _wrap_BinSummary___imul__, METH_VARARGS, NULL},
	{ (char *)"BinSummary___itruediv__", _wrap_BinSummary___itruediv__, METH_VARARGS, NULL},
	{ (char *)"BinSummary___mul__", _wrap_BinSummary___mul__, METH_VARARGS, NULL},
	{ (char *)"BinSummary___truediv__", _wrap_BinSummary___truediv__, METH_VARARGS, NULL},
	{ (char *)"BinSummary___iadd__", _wrap_BinSummary___iadd__, METH_VARARGS, NULL},
	{ (char *)"BinSummary___isub__", _wrap_BinSummary___isub__, METH_VARARGS, NULL},
	{ (char *)"BinSummary___add__", _wrap_BinSummary___add__, METH_VARARGS, NULL},
	{ (char *)"BinSummary___sub__", _wrap_BinSummary___sub__, METH_VARARGS, NULL},
	{ (char *)"BinSummary___eq__", _wrap_BinSummary___eq__, METH_VARARGS, NULL},
	{ (char *)"BinSummary___ne__", _wrap_BinSummary___ne__, METH_VARARGS, NULL},
	{ (char *)"BinSummary_classId", _wrap_BinSummary_classId, METH_VARARGS, NULL},
	{ (char *)"BinSummary_write", _wrap_BinSummary_write, METH_VARARGS, NULL},
	{ (char *)"BinSummary_classname", _wrap_BinSummary_classname, METH_VARARGS, NULL},
	{ (char *)"BinSummary_version", _wrap_BinSummary_version, METH_VARARGS, NULL},
	{ (char *)"BinSummary_restore", _wrap_BinSummary_restore, METH_VARARGS, NULL},
	{ (char *)"new_BinSummary", _wrap_new_BinSummary, METH_VARARGS, NULL},
	{ (char *)"delete_BinSummary", _wrap_delete_BinSummary, METH_VARARGS, NULL},
	{ (char *)"BinSummary_swigregister", BinSummary_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_StatAccArrayND", _wrap_delete_StatAccArrayND, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_uninitialize", _wrap_StatAccArrayND_uninitialize, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_reshape", _wrap_StatAccArrayND_reshape, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_valueAt", _wrap_StatAccArrayND_valueAt, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_linearPtr", _wrap_StatAccArrayND_linearPtr, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_convertLinearIndex", _wrap_StatAccArrayND_convertLinearIndex, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_linearIndex", _wrap_StatAccArrayND_linearIndex, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_length", _wrap_StatAccArrayND_length, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_data", _wrap_StatAccArrayND_data, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_isShapeKnown", _wrap_StatAccArrayND_isShapeKnown, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_rank", _wrap_StatAccArrayND_rank, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_shape", _wrap_StatAccArrayND_shape, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_shapeData", _wrap_StatAccArrayND_shapeData, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_fullRange", _wrap_StatAccArrayND_fullRange, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_span", _wrap_StatAccArrayND_span, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_maximumSpan", _wrap_StatAccArrayND_maximumSpan, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_minimumSpan", _wrap_StatAccArrayND_minimumSpan, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_strides", _wrap_StatAccArrayND_strides, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_isZero", _wrap_StatAccArrayND_isZero, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND___pos__", _wrap_StatAccArrayND___pos__, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_contract", _wrap_StatAccArrayND_contract, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_transpose", _wrap_StatAccArrayND_transpose, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_closestPtr", _wrap_StatAccArrayND_closestPtr, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_constFill", _wrap_StatAccArrayND_constFill, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_clear", _wrap_StatAccArrayND_clear, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_isCompatible", _wrap_StatAccArrayND_isCompatible, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_sliceShape", _wrap_StatAccArrayND_sliceShape, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_ptr", _wrap_StatAccArrayND_ptr, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_clPtr", _wrap_StatAccArrayND_clPtr, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_classId", _wrap_StatAccArrayND_classId, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_write", _wrap_StatAccArrayND_write, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_classname", _wrap_StatAccArrayND_classname, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_version", _wrap_StatAccArrayND_version, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_restore", _wrap_StatAccArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_setValue", _wrap_StatAccArrayND_setValue, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_value", _wrap_StatAccArrayND_value, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_setLinearValue", _wrap_StatAccArrayND_setLinearValue, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_linearValue", _wrap_StatAccArrayND_linearValue, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_setClosest", _wrap_StatAccArrayND_setClosest, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_closest", _wrap_StatAccArrayND_closest, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_set", _wrap_StatAccArrayND_set, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND___call__", _wrap_StatAccArrayND___call__, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_setCl", _wrap_StatAccArrayND_setCl, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_cl", _wrap_StatAccArrayND_cl, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_setData", _wrap_StatAccArrayND_setData, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND___eq__", _wrap_StatAccArrayND___eq__, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND___ne__", _wrap_StatAccArrayND___ne__, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND___add__", _wrap_StatAccArrayND___add__, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND___mul__", _wrap_StatAccArrayND___mul__, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND___div__", _wrap_StatAccArrayND___div__, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND___imul__", _wrap_StatAccArrayND___imul__, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND___idiv__", _wrap_StatAccArrayND___idiv__, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND___iadd__", _wrap_StatAccArrayND___iadd__, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_addmul", _wrap_StatAccArrayND_addmul, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_marginalize", _wrap_StatAccArrayND_marginalize, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_sum", _wrap_StatAccArrayND_sum, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_cdfValue", _wrap_StatAccArrayND_cdfValue, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_isShapeCompatible", _wrap_StatAccArrayND_isShapeCompatible, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_exportSlice", _wrap_StatAccArrayND_exportSlice, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_exportMemSlice", _wrap_StatAccArrayND_exportMemSlice, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_importSlice", _wrap_StatAccArrayND_importSlice, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_importMemSlice", _wrap_StatAccArrayND_importMemSlice, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_multiplyBySlice", _wrap_StatAccArrayND_multiplyBySlice, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_subrange", _wrap_StatAccArrayND_subrange, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_slice", _wrap_StatAccArrayND_slice, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_rotate", _wrap_StatAccArrayND_rotate, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_exportSubrange", _wrap_StatAccArrayND_exportSubrange, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_importSubrange", _wrap_StatAccArrayND_importSubrange, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_multiMirror", _wrap_StatAccArrayND_multiMirror, METH_VARARGS, NULL},
	{ (char *)"new_StatAccArrayND", _wrap_new_StatAccArrayND, METH_VARARGS, NULL},
	{ (char *)"StatAccArrayND_swigregister", StatAccArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_WStatAccArrayND", _wrap_delete_WStatAccArrayND, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_uninitialize", _wrap_WStatAccArrayND_uninitialize, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_reshape", _wrap_WStatAccArrayND_reshape, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_valueAt", _wrap_WStatAccArrayND_valueAt, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_linearPtr", _wrap_WStatAccArrayND_linearPtr, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_convertLinearIndex", _wrap_WStatAccArrayND_convertLinearIndex, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_linearIndex", _wrap_WStatAccArrayND_linearIndex, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_length", _wrap_WStatAccArrayND_length, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_data", _wrap_WStatAccArrayND_data, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_isShapeKnown", _wrap_WStatAccArrayND_isShapeKnown, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_rank", _wrap_WStatAccArrayND_rank, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_shape", _wrap_WStatAccArrayND_shape, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_shapeData", _wrap_WStatAccArrayND_shapeData, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_fullRange", _wrap_WStatAccArrayND_fullRange, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_span", _wrap_WStatAccArrayND_span, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_maximumSpan", _wrap_WStatAccArrayND_maximumSpan, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_minimumSpan", _wrap_WStatAccArrayND_minimumSpan, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_strides", _wrap_WStatAccArrayND_strides, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_isZero", _wrap_WStatAccArrayND_isZero, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND___pos__", _wrap_WStatAccArrayND___pos__, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_contract", _wrap_WStatAccArrayND_contract, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_transpose", _wrap_WStatAccArrayND_transpose, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_closestPtr", _wrap_WStatAccArrayND_closestPtr, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_constFill", _wrap_WStatAccArrayND_constFill, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_clear", _wrap_WStatAccArrayND_clear, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_isCompatible", _wrap_WStatAccArrayND_isCompatible, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_sliceShape", _wrap_WStatAccArrayND_sliceShape, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_ptr", _wrap_WStatAccArrayND_ptr, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_clPtr", _wrap_WStatAccArrayND_clPtr, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_classId", _wrap_WStatAccArrayND_classId, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_write", _wrap_WStatAccArrayND_write, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_classname", _wrap_WStatAccArrayND_classname, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_version", _wrap_WStatAccArrayND_version, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_restore", _wrap_WStatAccArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_setValue", _wrap_WStatAccArrayND_setValue, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_value", _wrap_WStatAccArrayND_value, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_setLinearValue", _wrap_WStatAccArrayND_setLinearValue, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_linearValue", _wrap_WStatAccArrayND_linearValue, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_setClosest", _wrap_WStatAccArrayND_setClosest, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_closest", _wrap_WStatAccArrayND_closest, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_set", _wrap_WStatAccArrayND_set, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND___call__", _wrap_WStatAccArrayND___call__, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_setCl", _wrap_WStatAccArrayND_setCl, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_cl", _wrap_WStatAccArrayND_cl, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_setData", _wrap_WStatAccArrayND_setData, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND___eq__", _wrap_WStatAccArrayND___eq__, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND___ne__", _wrap_WStatAccArrayND___ne__, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND___add__", _wrap_WStatAccArrayND___add__, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND___mul__", _wrap_WStatAccArrayND___mul__, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND___div__", _wrap_WStatAccArrayND___div__, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND___imul__", _wrap_WStatAccArrayND___imul__, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND___idiv__", _wrap_WStatAccArrayND___idiv__, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND___iadd__", _wrap_WStatAccArrayND___iadd__, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_addmul", _wrap_WStatAccArrayND_addmul, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_marginalize", _wrap_WStatAccArrayND_marginalize, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_sum", _wrap_WStatAccArrayND_sum, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_cdfValue", _wrap_WStatAccArrayND_cdfValue, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_isShapeCompatible", _wrap_WStatAccArrayND_isShapeCompatible, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_exportSlice", _wrap_WStatAccArrayND_exportSlice, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_exportMemSlice", _wrap_WStatAccArrayND_exportMemSlice, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_importSlice", _wrap_WStatAccArrayND_importSlice, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_importMemSlice", _wrap_WStatAccArrayND_importMemSlice, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_multiplyBySlice", _wrap_WStatAccArrayND_multiplyBySlice, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_subrange", _wrap_WStatAccArrayND_subrange, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_slice", _wrap_WStatAccArrayND_slice, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_rotate", _wrap_WStatAccArrayND_rotate, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_exportSubrange", _wrap_WStatAccArrayND_exportSubrange, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_importSubrange", _wrap_WStatAccArrayND_importSubrange, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_multiMirror", _wrap_WStatAccArrayND_multiMirror, METH_VARARGS, NULL},
	{ (char *)"new_WStatAccArrayND", _wrap_new_WStatAccArrayND, METH_VARARGS, NULL},
	{ (char *)"WStatAccArrayND_swigregister", WStatAccArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_FSampleAccArrayND", _wrap_delete_FSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_uninitialize", _wrap_FSampleAccArrayND_uninitialize, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_reshape", _wrap_FSampleAccArrayND_reshape, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_valueAt", _wrap_FSampleAccArrayND_valueAt, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_linearPtr", _wrap_FSampleAccArrayND_linearPtr, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_convertLinearIndex", _wrap_FSampleAccArrayND_convertLinearIndex, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_linearIndex", _wrap_FSampleAccArrayND_linearIndex, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_length", _wrap_FSampleAccArrayND_length, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_data", _wrap_FSampleAccArrayND_data, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_isShapeKnown", _wrap_FSampleAccArrayND_isShapeKnown, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_rank", _wrap_FSampleAccArrayND_rank, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_shape", _wrap_FSampleAccArrayND_shape, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_shapeData", _wrap_FSampleAccArrayND_shapeData, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_fullRange", _wrap_FSampleAccArrayND_fullRange, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_span", _wrap_FSampleAccArrayND_span, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_maximumSpan", _wrap_FSampleAccArrayND_maximumSpan, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_minimumSpan", _wrap_FSampleAccArrayND_minimumSpan, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_strides", _wrap_FSampleAccArrayND_strides, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_isZero", _wrap_FSampleAccArrayND_isZero, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND___pos__", _wrap_FSampleAccArrayND___pos__, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_contract", _wrap_FSampleAccArrayND_contract, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_transpose", _wrap_FSampleAccArrayND_transpose, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_closestPtr", _wrap_FSampleAccArrayND_closestPtr, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_constFill", _wrap_FSampleAccArrayND_constFill, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_clear", _wrap_FSampleAccArrayND_clear, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_isCompatible", _wrap_FSampleAccArrayND_isCompatible, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_sliceShape", _wrap_FSampleAccArrayND_sliceShape, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_ptr", _wrap_FSampleAccArrayND_ptr, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_clPtr", _wrap_FSampleAccArrayND_clPtr, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_classId", _wrap_FSampleAccArrayND_classId, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_write", _wrap_FSampleAccArrayND_write, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_classname", _wrap_FSampleAccArrayND_classname, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_version", _wrap_FSampleAccArrayND_version, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_restore", _wrap_FSampleAccArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_setValue", _wrap_FSampleAccArrayND_setValue, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_value", _wrap_FSampleAccArrayND_value, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_setLinearValue", _wrap_FSampleAccArrayND_setLinearValue, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_linearValue", _wrap_FSampleAccArrayND_linearValue, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_setClosest", _wrap_FSampleAccArrayND_setClosest, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_closest", _wrap_FSampleAccArrayND_closest, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_set", _wrap_FSampleAccArrayND_set, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND___call__", _wrap_FSampleAccArrayND___call__, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_setCl", _wrap_FSampleAccArrayND_setCl, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_cl", _wrap_FSampleAccArrayND_cl, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_setData", _wrap_FSampleAccArrayND_setData, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND___eq__", _wrap_FSampleAccArrayND___eq__, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND___ne__", _wrap_FSampleAccArrayND___ne__, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND___add__", _wrap_FSampleAccArrayND___add__, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND___mul__", _wrap_FSampleAccArrayND___mul__, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND___div__", _wrap_FSampleAccArrayND___div__, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND___imul__", _wrap_FSampleAccArrayND___imul__, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND___idiv__", _wrap_FSampleAccArrayND___idiv__, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND___iadd__", _wrap_FSampleAccArrayND___iadd__, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_addmul", _wrap_FSampleAccArrayND_addmul, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_marginalize", _wrap_FSampleAccArrayND_marginalize, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_sum", _wrap_FSampleAccArrayND_sum, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_cdfValue", _wrap_FSampleAccArrayND_cdfValue, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_isShapeCompatible", _wrap_FSampleAccArrayND_isShapeCompatible, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_exportSlice", _wrap_FSampleAccArrayND_exportSlice, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_exportMemSlice", _wrap_FSampleAccArrayND_exportMemSlice, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_importSlice", _wrap_FSampleAccArrayND_importSlice, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_importMemSlice", _wrap_FSampleAccArrayND_importMemSlice, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_multiplyBySlice", _wrap_FSampleAccArrayND_multiplyBySlice, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_subrange", _wrap_FSampleAccArrayND_subrange, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_slice", _wrap_FSampleAccArrayND_slice, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_rotate", _wrap_FSampleAccArrayND_rotate, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_exportSubrange", _wrap_FSampleAccArrayND_exportSubrange, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_importSubrange", _wrap_FSampleAccArrayND_importSubrange, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_multiMirror", _wrap_FSampleAccArrayND_multiMirror, METH_VARARGS, NULL},
	{ (char *)"new_FSampleAccArrayND", _wrap_new_FSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"FSampleAccArrayND_swigregister", FSampleAccArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DSampleAccArrayND", _wrap_delete_DSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_uninitialize", _wrap_DSampleAccArrayND_uninitialize, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_reshape", _wrap_DSampleAccArrayND_reshape, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_valueAt", _wrap_DSampleAccArrayND_valueAt, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_linearPtr", _wrap_DSampleAccArrayND_linearPtr, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_convertLinearIndex", _wrap_DSampleAccArrayND_convertLinearIndex, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_linearIndex", _wrap_DSampleAccArrayND_linearIndex, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_length", _wrap_DSampleAccArrayND_length, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_data", _wrap_DSampleAccArrayND_data, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_isShapeKnown", _wrap_DSampleAccArrayND_isShapeKnown, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_rank", _wrap_DSampleAccArrayND_rank, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_shape", _wrap_DSampleAccArrayND_shape, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_shapeData", _wrap_DSampleAccArrayND_shapeData, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_fullRange", _wrap_DSampleAccArrayND_fullRange, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_span", _wrap_DSampleAccArrayND_span, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_maximumSpan", _wrap_DSampleAccArrayND_maximumSpan, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_minimumSpan", _wrap_DSampleAccArrayND_minimumSpan, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_strides", _wrap_DSampleAccArrayND_strides, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_isZero", _wrap_DSampleAccArrayND_isZero, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND___pos__", _wrap_DSampleAccArrayND___pos__, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_contract", _wrap_DSampleAccArrayND_contract, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_transpose", _wrap_DSampleAccArrayND_transpose, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_closestPtr", _wrap_DSampleAccArrayND_closestPtr, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_constFill", _wrap_DSampleAccArrayND_constFill, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_clear", _wrap_DSampleAccArrayND_clear, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_isCompatible", _wrap_DSampleAccArrayND_isCompatible, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_sliceShape", _wrap_DSampleAccArrayND_sliceShape, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_ptr", _wrap_DSampleAccArrayND_ptr, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_clPtr", _wrap_DSampleAccArrayND_clPtr, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_classId", _wrap_DSampleAccArrayND_classId, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_write", _wrap_DSampleAccArrayND_write, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_classname", _wrap_DSampleAccArrayND_classname, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_version", _wrap_DSampleAccArrayND_version, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_restore", _wrap_DSampleAccArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_setValue", _wrap_DSampleAccArrayND_setValue, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_value", _wrap_DSampleAccArrayND_value, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_setLinearValue", _wrap_DSampleAccArrayND_setLinearValue, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_linearValue", _wrap_DSampleAccArrayND_linearValue, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_setClosest", _wrap_DSampleAccArrayND_setClosest, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_closest", _wrap_DSampleAccArrayND_closest, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_set", _wrap_DSampleAccArrayND_set, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND___call__", _wrap_DSampleAccArrayND___call__, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_setCl", _wrap_DSampleAccArrayND_setCl, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_cl", _wrap_DSampleAccArrayND_cl, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_setData", _wrap_DSampleAccArrayND_setData, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND___eq__", _wrap_DSampleAccArrayND___eq__, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND___ne__", _wrap_DSampleAccArrayND___ne__, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND___add__", _wrap_DSampleAccArrayND___add__, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND___mul__", _wrap_DSampleAccArrayND___mul__, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND___div__", _wrap_DSampleAccArrayND___div__, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND___imul__", _wrap_DSampleAccArrayND___imul__, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND___idiv__", _wrap_DSampleAccArrayND___idiv__, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND___iadd__", _wrap_DSampleAccArrayND___iadd__, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_addmul", _wrap_DSampleAccArrayND_addmul, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_marginalize", _wrap_DSampleAccArrayND_marginalize, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_sum", _wrap_DSampleAccArrayND_sum, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_cdfValue", _wrap_DSampleAccArrayND_cdfValue, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_isShapeCompatible", _wrap_DSampleAccArrayND_isShapeCompatible, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_exportSlice", _wrap_DSampleAccArrayND_exportSlice, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_exportMemSlice", _wrap_DSampleAccArrayND_exportMemSlice, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_importSlice", _wrap_DSampleAccArrayND_importSlice, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_importMemSlice", _wrap_DSampleAccArrayND_importMemSlice, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_multiplyBySlice", _wrap_DSampleAccArrayND_multiplyBySlice, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_subrange", _wrap_DSampleAccArrayND_subrange, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_slice", _wrap_DSampleAccArrayND_slice, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_rotate", _wrap_DSampleAccArrayND_rotate, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_exportSubrange", _wrap_DSampleAccArrayND_exportSubrange, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_importSubrange", _wrap_DSampleAccArrayND_importSubrange, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_multiMirror", _wrap_DSampleAccArrayND_multiMirror, METH_VARARGS, NULL},
	{ (char *)"new_DSampleAccArrayND", _wrap_new_DSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"DSampleAccArrayND_swigregister", DSampleAccArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DWSampleAccArrayND", _wrap_delete_DWSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_uninitialize", _wrap_DWSampleAccArrayND_uninitialize, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_reshape", _wrap_DWSampleAccArrayND_reshape, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_valueAt", _wrap_DWSampleAccArrayND_valueAt, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_linearPtr", _wrap_DWSampleAccArrayND_linearPtr, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_convertLinearIndex", _wrap_DWSampleAccArrayND_convertLinearIndex, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_linearIndex", _wrap_DWSampleAccArrayND_linearIndex, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_length", _wrap_DWSampleAccArrayND_length, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_data", _wrap_DWSampleAccArrayND_data, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_isShapeKnown", _wrap_DWSampleAccArrayND_isShapeKnown, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_rank", _wrap_DWSampleAccArrayND_rank, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_shape", _wrap_DWSampleAccArrayND_shape, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_shapeData", _wrap_DWSampleAccArrayND_shapeData, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_fullRange", _wrap_DWSampleAccArrayND_fullRange, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_span", _wrap_DWSampleAccArrayND_span, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_maximumSpan", _wrap_DWSampleAccArrayND_maximumSpan, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_minimumSpan", _wrap_DWSampleAccArrayND_minimumSpan, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_strides", _wrap_DWSampleAccArrayND_strides, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_isZero", _wrap_DWSampleAccArrayND_isZero, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND___pos__", _wrap_DWSampleAccArrayND___pos__, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_contract", _wrap_DWSampleAccArrayND_contract, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_transpose", _wrap_DWSampleAccArrayND_transpose, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_closestPtr", _wrap_DWSampleAccArrayND_closestPtr, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_constFill", _wrap_DWSampleAccArrayND_constFill, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_clear", _wrap_DWSampleAccArrayND_clear, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_isCompatible", _wrap_DWSampleAccArrayND_isCompatible, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_sliceShape", _wrap_DWSampleAccArrayND_sliceShape, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_ptr", _wrap_DWSampleAccArrayND_ptr, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_clPtr", _wrap_DWSampleAccArrayND_clPtr, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_classId", _wrap_DWSampleAccArrayND_classId, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_write", _wrap_DWSampleAccArrayND_write, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_classname", _wrap_DWSampleAccArrayND_classname, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_version", _wrap_DWSampleAccArrayND_version, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_restore", _wrap_DWSampleAccArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_setValue", _wrap_DWSampleAccArrayND_setValue, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_value", _wrap_DWSampleAccArrayND_value, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_setLinearValue", _wrap_DWSampleAccArrayND_setLinearValue, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_linearValue", _wrap_DWSampleAccArrayND_linearValue, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_setClosest", _wrap_DWSampleAccArrayND_setClosest, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_closest", _wrap_DWSampleAccArrayND_closest, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_set", _wrap_DWSampleAccArrayND_set, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND___call__", _wrap_DWSampleAccArrayND___call__, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_setCl", _wrap_DWSampleAccArrayND_setCl, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_cl", _wrap_DWSampleAccArrayND_cl, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_setData", _wrap_DWSampleAccArrayND_setData, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND___eq__", _wrap_DWSampleAccArrayND___eq__, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND___ne__", _wrap_DWSampleAccArrayND___ne__, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND___add__", _wrap_DWSampleAccArrayND___add__, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND___mul__", _wrap_DWSampleAccArrayND___mul__, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND___div__", _wrap_DWSampleAccArrayND___div__, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND___imul__", _wrap_DWSampleAccArrayND___imul__, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND___idiv__", _wrap_DWSampleAccArrayND___idiv__, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND___iadd__", _wrap_DWSampleAccArrayND___iadd__, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_addmul", _wrap_DWSampleAccArrayND_addmul, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_marginalize", _wrap_DWSampleAccArrayND_marginalize, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_sum", _wrap_DWSampleAccArrayND_sum, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_cdfValue", _wrap_DWSampleAccArrayND_cdfValue, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_isShapeCompatible", _wrap_DWSampleAccArrayND_isShapeCompatible, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_exportSlice", _wrap_DWSampleAccArrayND_exportSlice, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_exportMemSlice", _wrap_DWSampleAccArrayND_exportMemSlice, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_importSlice", _wrap_DWSampleAccArrayND_importSlice, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_importMemSlice", _wrap_DWSampleAccArrayND_importMemSlice, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_multiplyBySlice", _wrap_DWSampleAccArrayND_multiplyBySlice, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_subrange", _wrap_DWSampleAccArrayND_subrange, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_slice", _wrap_DWSampleAccArrayND_slice, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_rotate", _wrap_DWSampleAccArrayND_rotate, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_exportSubrange", _wrap_DWSampleAccArrayND_exportSubrange, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_importSubrange", _wrap_DWSampleAccArrayND_importSubrange, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_multiMirror", _wrap_DWSampleAccArrayND_multiMirror, METH_VARARGS, NULL},
	{ (char *)"new_DWSampleAccArrayND", _wrap_new_DWSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccArrayND_swigregister", DWSampleAccArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_BinSummaryArrayND", _wrap_delete_BinSummaryArrayND, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_uninitialize", _wrap_BinSummaryArrayND_uninitialize, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_reshape", _wrap_BinSummaryArrayND_reshape, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_valueAt", _wrap_BinSummaryArrayND_valueAt, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_linearPtr", _wrap_BinSummaryArrayND_linearPtr, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_convertLinearIndex", _wrap_BinSummaryArrayND_convertLinearIndex, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_linearIndex", _wrap_BinSummaryArrayND_linearIndex, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_length", _wrap_BinSummaryArrayND_length, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_data", _wrap_BinSummaryArrayND_data, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_isShapeKnown", _wrap_BinSummaryArrayND_isShapeKnown, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_rank", _wrap_BinSummaryArrayND_rank, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_shape", _wrap_BinSummaryArrayND_shape, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_shapeData", _wrap_BinSummaryArrayND_shapeData, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_fullRange", _wrap_BinSummaryArrayND_fullRange, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_span", _wrap_BinSummaryArrayND_span, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_maximumSpan", _wrap_BinSummaryArrayND_maximumSpan, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_minimumSpan", _wrap_BinSummaryArrayND_minimumSpan, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_strides", _wrap_BinSummaryArrayND_strides, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_isZero", _wrap_BinSummaryArrayND_isZero, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND___pos__", _wrap_BinSummaryArrayND___pos__, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_contract", _wrap_BinSummaryArrayND_contract, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_transpose", _wrap_BinSummaryArrayND_transpose, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_closestPtr", _wrap_BinSummaryArrayND_closestPtr, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_constFill", _wrap_BinSummaryArrayND_constFill, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_clear", _wrap_BinSummaryArrayND_clear, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_isCompatible", _wrap_BinSummaryArrayND_isCompatible, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_sliceShape", _wrap_BinSummaryArrayND_sliceShape, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_ptr", _wrap_BinSummaryArrayND_ptr, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_clPtr", _wrap_BinSummaryArrayND_clPtr, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_classId", _wrap_BinSummaryArrayND_classId, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_write", _wrap_BinSummaryArrayND_write, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_classname", _wrap_BinSummaryArrayND_classname, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_version", _wrap_BinSummaryArrayND_version, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_restore", _wrap_BinSummaryArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_setValue", _wrap_BinSummaryArrayND_setValue, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_value", _wrap_BinSummaryArrayND_value, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_setLinearValue", _wrap_BinSummaryArrayND_setLinearValue, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_linearValue", _wrap_BinSummaryArrayND_linearValue, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_setClosest", _wrap_BinSummaryArrayND_setClosest, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_closest", _wrap_BinSummaryArrayND_closest, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_set", _wrap_BinSummaryArrayND_set, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND___call__", _wrap_BinSummaryArrayND___call__, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_setCl", _wrap_BinSummaryArrayND_setCl, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_cl", _wrap_BinSummaryArrayND_cl, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_setData", _wrap_BinSummaryArrayND_setData, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND___eq__", _wrap_BinSummaryArrayND___eq__, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND___ne__", _wrap_BinSummaryArrayND___ne__, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND___add__", _wrap_BinSummaryArrayND___add__, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND___mul__", _wrap_BinSummaryArrayND___mul__, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND___div__", _wrap_BinSummaryArrayND___div__, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND___imul__", _wrap_BinSummaryArrayND___imul__, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND___idiv__", _wrap_BinSummaryArrayND___idiv__, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND___iadd__", _wrap_BinSummaryArrayND___iadd__, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_addmul", _wrap_BinSummaryArrayND_addmul, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_marginalize", _wrap_BinSummaryArrayND_marginalize, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_sum", _wrap_BinSummaryArrayND_sum, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_cdfValue", _wrap_BinSummaryArrayND_cdfValue, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_isShapeCompatible", _wrap_BinSummaryArrayND_isShapeCompatible, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_exportSlice", _wrap_BinSummaryArrayND_exportSlice, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_exportMemSlice", _wrap_BinSummaryArrayND_exportMemSlice, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_importSlice", _wrap_BinSummaryArrayND_importSlice, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_importMemSlice", _wrap_BinSummaryArrayND_importMemSlice, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_multiplyBySlice", _wrap_BinSummaryArrayND_multiplyBySlice, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_subrange", _wrap_BinSummaryArrayND_subrange, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_slice", _wrap_BinSummaryArrayND_slice, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_rotate", _wrap_BinSummaryArrayND_rotate, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_exportSubrange", _wrap_BinSummaryArrayND_exportSubrange, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_importSubrange", _wrap_BinSummaryArrayND_importSubrange, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_multiMirror", _wrap_BinSummaryArrayND_multiMirror, METH_VARARGS, NULL},
	{ (char *)"new_BinSummaryArrayND", _wrap_new_BinSummaryArrayND, METH_VARARGS, NULL},
	{ (char *)"new_ArrayND", _wrap_new_ArrayND, METH_VARARGS, NULL},
	{ (char *)"BinSummaryArrayND_swigregister", BinSummaryArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_StatAccArrayND", _wrap_new_ArchiveRecord_StatAccArrayND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_StatAccArrayND", _wrap_delete_ArchiveRecord_StatAccArrayND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_StatAccArrayND_swigregister", ArchiveRecord_StatAccArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_StatAccArrayND", _wrap_new_Ref_StatAccArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_StatAccArrayND_restore", _wrap_Ref_StatAccArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_StatAccArrayND_retrieve", _wrap_Ref_StatAccArrayND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_StatAccArrayND_getValue", _wrap_Ref_StatAccArrayND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_StatAccArrayND", _wrap_delete_Ref_StatAccArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_StatAccArrayND_swigregister", Ref_StatAccArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_WStatAccArrayND", _wrap_new_ArchiveRecord_WStatAccArrayND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_WStatAccArrayND", _wrap_delete_ArchiveRecord_WStatAccArrayND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_WStatAccArrayND_swigregister", ArchiveRecord_WStatAccArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_WStatAccArrayND", _wrap_new_Ref_WStatAccArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_WStatAccArrayND_restore", _wrap_Ref_WStatAccArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_WStatAccArrayND_retrieve", _wrap_Ref_WStatAccArrayND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_WStatAccArrayND_getValue", _wrap_Ref_WStatAccArrayND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_WStatAccArrayND", _wrap_delete_Ref_WStatAccArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_WStatAccArrayND_swigregister", Ref_WStatAccArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_FSampleAccArrayND", _wrap_new_ArchiveRecord_FSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_FSampleAccArrayND", _wrap_delete_ArchiveRecord_FSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_FSampleAccArrayND_swigregister", ArchiveRecord_FSampleAccArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_FSampleAccArrayND", _wrap_new_Ref_FSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_FSampleAccArrayND_restore", _wrap_Ref_FSampleAccArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_FSampleAccArrayND_retrieve", _wrap_Ref_FSampleAccArrayND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_FSampleAccArrayND_getValue", _wrap_Ref_FSampleAccArrayND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_FSampleAccArrayND", _wrap_delete_Ref_FSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_FSampleAccArrayND_swigregister", Ref_FSampleAccArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DSampleAccArrayND", _wrap_new_ArchiveRecord_DSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DSampleAccArrayND", _wrap_delete_ArchiveRecord_DSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DSampleAccArrayND_swigregister", ArchiveRecord_DSampleAccArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DSampleAccArrayND", _wrap_new_Ref_DSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_DSampleAccArrayND_restore", _wrap_Ref_DSampleAccArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DSampleAccArrayND_retrieve", _wrap_Ref_DSampleAccArrayND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DSampleAccArrayND_getValue", _wrap_Ref_DSampleAccArrayND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DSampleAccArrayND", _wrap_delete_Ref_DSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_DSampleAccArrayND_swigregister", Ref_DSampleAccArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DWSampleAccArrayND", _wrap_new_ArchiveRecord_DWSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DWSampleAccArrayND", _wrap_delete_ArchiveRecord_DWSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DWSampleAccArrayND_swigregister", ArchiveRecord_DWSampleAccArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DWSampleAccArrayND", _wrap_new_Ref_DWSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_DWSampleAccArrayND_restore", _wrap_Ref_DWSampleAccArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DWSampleAccArrayND_retrieve", _wrap_Ref_DWSampleAccArrayND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DWSampleAccArrayND_getValue", _wrap_Ref_DWSampleAccArrayND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DWSampleAccArrayND", _wrap_delete_Ref_DWSampleAccArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_DWSampleAccArrayND_swigregister", Ref_DWSampleAccArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_BinSummaryArrayND", _wrap_new_ArchiveRecord_BinSummaryArrayND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_BinSummaryArrayND", _wrap_delete_ArchiveRecord_BinSummaryArrayND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_BinSummaryArrayND_swigregister", ArchiveRecord_BinSummaryArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_BinSummaryArrayND", _wrap_new_Ref_BinSummaryArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_BinSummaryArrayND_restore", _wrap_Ref_BinSummaryArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_BinSummaryArrayND_retrieve", _wrap_Ref_BinSummaryArrayND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_BinSummaryArrayND_getValue", _wrap_Ref_BinSummaryArrayND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_BinSummaryArrayND", _wrap_delete_Ref_BinSummaryArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_BinSummaryArrayND_swigregister", Ref_BinSummaryArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_UCharArrayND", _wrap_delete_UCharArrayND, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_uninitialize", _wrap_UCharArrayND_uninitialize, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_reshape", _wrap_UCharArrayND_reshape, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_valueAt", _wrap_UCharArrayND_valueAt, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_linearPtr", _wrap_UCharArrayND_linearPtr, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_convertLinearIndex", _wrap_UCharArrayND_convertLinearIndex, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_linearIndex", _wrap_UCharArrayND_linearIndex, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_length", _wrap_UCharArrayND_length, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_data", _wrap_UCharArrayND_data, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_isShapeKnown", _wrap_UCharArrayND_isShapeKnown, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_rank", _wrap_UCharArrayND_rank, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_shape", _wrap_UCharArrayND_shape, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_shapeData", _wrap_UCharArrayND_shapeData, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_fullRange", _wrap_UCharArrayND_fullRange, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_span", _wrap_UCharArrayND_span, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_maximumSpan", _wrap_UCharArrayND_maximumSpan, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_minimumSpan", _wrap_UCharArrayND_minimumSpan, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_strides", _wrap_UCharArrayND_strides, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_isZero", _wrap_UCharArrayND_isZero, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_isDensity", _wrap_UCharArrayND_isDensity, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND___pos__", _wrap_UCharArrayND___pos__, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND___neg__", _wrap_UCharArrayND___neg__, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_contract", _wrap_UCharArrayND_contract, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_transpose", _wrap_UCharArrayND_transpose, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_min", _wrap_UCharArrayND_min, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_max", _wrap_UCharArrayND_max, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_closestPtr", _wrap_UCharArrayND_closestPtr, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_interpolate1", _wrap_UCharArrayND_interpolate1, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_interpolate3", _wrap_UCharArrayND_interpolate3, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_constFill", _wrap_UCharArrayND_constFill, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_clear", _wrap_UCharArrayND_clear, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_linearFill", _wrap_UCharArrayND_linearFill, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_makeUnit", _wrap_UCharArrayND_makeUnit, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_makeNonNegative", _wrap_UCharArrayND_makeNonNegative, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_makeCopulaSteps", _wrap_UCharArrayND_makeCopulaSteps, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_isCompatible", _wrap_UCharArrayND_isCompatible, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_sliceShape", _wrap_UCharArrayND_sliceShape, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_ptr", _wrap_UCharArrayND_ptr, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_clPtr", _wrap_UCharArrayND_clPtr, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_classId", _wrap_UCharArrayND_classId, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_write", _wrap_UCharArrayND_write, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_classname", _wrap_UCharArrayND_classname, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_version", _wrap_UCharArrayND_version, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_restore", _wrap_UCharArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_setValue", _wrap_UCharArrayND_setValue, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_value", _wrap_UCharArrayND_value, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_setLinearValue", _wrap_UCharArrayND_setLinearValue, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_linearValue", _wrap_UCharArrayND_linearValue, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_setClosest", _wrap_UCharArrayND_setClosest, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_closest", _wrap_UCharArrayND_closest, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_set", _wrap_UCharArrayND_set, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND___call__", _wrap_UCharArrayND___call__, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_setCl", _wrap_UCharArrayND_setCl, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_cl", _wrap_UCharArrayND_cl, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_setData", _wrap_UCharArrayND_setData, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_maxAbsDifference", _wrap_UCharArrayND_maxAbsDifference, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND___eq__", _wrap_UCharArrayND___eq__, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND___ne__", _wrap_UCharArrayND___ne__, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND___add__", _wrap_UCharArrayND___add__, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND___sub__", _wrap_UCharArrayND___sub__, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND___mul__", _wrap_UCharArrayND___mul__, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND___div__", _wrap_UCharArrayND___div__, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND___imul__", _wrap_UCharArrayND___imul__, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND___idiv__", _wrap_UCharArrayND___idiv__, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND___iadd__", _wrap_UCharArrayND___iadd__, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND___isub__", _wrap_UCharArrayND___isub__, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_addmul", _wrap_UCharArrayND_addmul, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_inPlaceMul", _wrap_UCharArrayND_inPlaceMul, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_outer", _wrap_UCharArrayND_outer, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_dot", _wrap_UCharArrayND_dot, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_marginalize", _wrap_UCharArrayND_marginalize, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_sum", _wrap_UCharArrayND_sum, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_sumsq", _wrap_UCharArrayND_sumsq, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_derivative", _wrap_UCharArrayND_derivative, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_cdfArray", _wrap_UCharArrayND_cdfArray, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_cdfValue", _wrap_UCharArrayND_cdfValue, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_convertToLastDimCdf", _wrap_UCharArrayND_convertToLastDimCdf, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_isClose", _wrap_UCharArrayND_isClose, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_isShapeCompatible", _wrap_UCharArrayND_isShapeCompatible, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_exportSlice", _wrap_UCharArrayND_exportSlice, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_exportMemSlice", _wrap_UCharArrayND_exportMemSlice, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_importSlice", _wrap_UCharArrayND_importSlice, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_importMemSlice", _wrap_UCharArrayND_importMemSlice, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_multiplyBySlice", _wrap_UCharArrayND_multiplyBySlice, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_subrange", _wrap_UCharArrayND_subrange, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_slice", _wrap_UCharArrayND_slice, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_rotate", _wrap_UCharArrayND_rotate, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_exportSubrange", _wrap_UCharArrayND_exportSubrange, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_importSubrange", _wrap_UCharArrayND_importSubrange, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_multiMirror", _wrap_UCharArrayND_multiMirror, METH_VARARGS, NULL},
	{ (char *)"new_UCharArrayND", _wrap_new_UCharArrayND, METH_VARARGS, NULL},
	{ (char *)"UCharArrayND_swigregister", UCharArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_UCharArrayND", _wrap_new_ArchiveRecord_UCharArrayND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_UCharArrayND", _wrap_delete_ArchiveRecord_UCharArrayND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_UCharArrayND_swigregister", ArchiveRecord_UCharArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_UCharArrayND", _wrap_new_Ref_UCharArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharArrayND_restore", _wrap_Ref_UCharArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharArrayND_retrieve", _wrap_Ref_UCharArrayND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharArrayND_getValue", _wrap_Ref_UCharArrayND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_UCharArrayND", _wrap_delete_Ref_UCharArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharArrayND_swigregister", Ref_UCharArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_IntArrayND", _wrap_delete_IntArrayND, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_uninitialize", _wrap_IntArrayND_uninitialize, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_reshape", _wrap_IntArrayND_reshape, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_valueAt", _wrap_IntArrayND_valueAt, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_linearPtr", _wrap_IntArrayND_linearPtr, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_convertLinearIndex", _wrap_IntArrayND_convertLinearIndex, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_linearIndex", _wrap_IntArrayND_linearIndex, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_length", _wrap_IntArrayND_length, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_data", _wrap_IntArrayND_data, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_isShapeKnown", _wrap_IntArrayND_isShapeKnown, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_rank", _wrap_IntArrayND_rank, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_shape", _wrap_IntArrayND_shape, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_shapeData", _wrap_IntArrayND_shapeData, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_fullRange", _wrap_IntArrayND_fullRange, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_span", _wrap_IntArrayND_span, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_maximumSpan", _wrap_IntArrayND_maximumSpan, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_minimumSpan", _wrap_IntArrayND_minimumSpan, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_strides", _wrap_IntArrayND_strides, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_isZero", _wrap_IntArrayND_isZero, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_isDensity", _wrap_IntArrayND_isDensity, METH_VARARGS, NULL},
	{ (char *)"IntArrayND___pos__", _wrap_IntArrayND___pos__, METH_VARARGS, NULL},
	{ (char *)"IntArrayND___neg__", _wrap_IntArrayND___neg__, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_contract", _wrap_IntArrayND_contract, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_transpose", _wrap_IntArrayND_transpose, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_min", _wrap_IntArrayND_min, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_max", _wrap_IntArrayND_max, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_closestPtr", _wrap_IntArrayND_closestPtr, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_interpolate1", _wrap_IntArrayND_interpolate1, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_interpolate3", _wrap_IntArrayND_interpolate3, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_constFill", _wrap_IntArrayND_constFill, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_clear", _wrap_IntArrayND_clear, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_linearFill", _wrap_IntArrayND_linearFill, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_makeUnit", _wrap_IntArrayND_makeUnit, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_makeNonNegative", _wrap_IntArrayND_makeNonNegative, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_makeCopulaSteps", _wrap_IntArrayND_makeCopulaSteps, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_isCompatible", _wrap_IntArrayND_isCompatible, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_sliceShape", _wrap_IntArrayND_sliceShape, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_ptr", _wrap_IntArrayND_ptr, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_clPtr", _wrap_IntArrayND_clPtr, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_classId", _wrap_IntArrayND_classId, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_write", _wrap_IntArrayND_write, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_classname", _wrap_IntArrayND_classname, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_version", _wrap_IntArrayND_version, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_restore", _wrap_IntArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_setValue", _wrap_IntArrayND_setValue, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_value", _wrap_IntArrayND_value, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_setLinearValue", _wrap_IntArrayND_setLinearValue, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_linearValue", _wrap_IntArrayND_linearValue, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_setClosest", _wrap_IntArrayND_setClosest, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_closest", _wrap_IntArrayND_closest, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_set", _wrap_IntArrayND_set, METH_VARARGS, NULL},
	{ (char *)"IntArrayND___call__", _wrap_IntArrayND___call__, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_setCl", _wrap_IntArrayND_setCl, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_cl", _wrap_IntArrayND_cl, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_setData", _wrap_IntArrayND_setData, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_maxAbsDifference", _wrap_IntArrayND_maxAbsDifference, METH_VARARGS, NULL},
	{ (char *)"IntArrayND___eq__", _wrap_IntArrayND___eq__, METH_VARARGS, NULL},
	{ (char *)"IntArrayND___ne__", _wrap_IntArrayND___ne__, METH_VARARGS, NULL},
	{ (char *)"IntArrayND___add__", _wrap_IntArrayND___add__, METH_VARARGS, NULL},
	{ (char *)"IntArrayND___sub__", _wrap_IntArrayND___sub__, METH_VARARGS, NULL},
	{ (char *)"IntArrayND___mul__", _wrap_IntArrayND___mul__, METH_VARARGS, NULL},
	{ (char *)"IntArrayND___div__", _wrap_IntArrayND___div__, METH_VARARGS, NULL},
	{ (char *)"IntArrayND___imul__", _wrap_IntArrayND___imul__, METH_VARARGS, NULL},
	{ (char *)"IntArrayND___idiv__", _wrap_IntArrayND___idiv__, METH_VARARGS, NULL},
	{ (char *)"IntArrayND___iadd__", _wrap_IntArrayND___iadd__, METH_VARARGS, NULL},
	{ (char *)"IntArrayND___isub__", _wrap_IntArrayND___isub__, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_addmul", _wrap_IntArrayND_addmul, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_inPlaceMul", _wrap_IntArrayND_inPlaceMul, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_outer", _wrap_IntArrayND_outer, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_dot", _wrap_IntArrayND_dot, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_marginalize", _wrap_IntArrayND_marginalize, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_sum", _wrap_IntArrayND_sum, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_sumsq", _wrap_IntArrayND_sumsq, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_derivative", _wrap_IntArrayND_derivative, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_cdfArray", _wrap_IntArrayND_cdfArray, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_cdfValue", _wrap_IntArrayND_cdfValue, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_convertToLastDimCdf", _wrap_IntArrayND_convertToLastDimCdf, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_isClose", _wrap_IntArrayND_isClose, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_isShapeCompatible", _wrap_IntArrayND_isShapeCompatible, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_exportSlice", _wrap_IntArrayND_exportSlice, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_exportMemSlice", _wrap_IntArrayND_exportMemSlice, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_importSlice", _wrap_IntArrayND_importSlice, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_importMemSlice", _wrap_IntArrayND_importMemSlice, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_multiplyBySlice", _wrap_IntArrayND_multiplyBySlice, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_subrange", _wrap_IntArrayND_subrange, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_slice", _wrap_IntArrayND_slice, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_rotate", _wrap_IntArrayND_rotate, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_exportSubrange", _wrap_IntArrayND_exportSubrange, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_importSubrange", _wrap_IntArrayND_importSubrange, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_multiMirror", _wrap_IntArrayND_multiMirror, METH_VARARGS, NULL},
	{ (char *)"new_IntArrayND", _wrap_new_IntArrayND, METH_VARARGS, NULL},
	{ (char *)"IntArrayND_swigregister", IntArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_IntArrayND", _wrap_new_ArchiveRecord_IntArrayND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_IntArrayND", _wrap_delete_ArchiveRecord_IntArrayND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_IntArrayND_swigregister", ArchiveRecord_IntArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_IntArrayND", _wrap_new_Ref_IntArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_IntArrayND_restore", _wrap_Ref_IntArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_IntArrayND_retrieve", _wrap_Ref_IntArrayND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_IntArrayND_getValue", _wrap_Ref_IntArrayND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_IntArrayND", _wrap_delete_Ref_IntArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_IntArrayND_swigregister", Ref_IntArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_LLongArrayND", _wrap_delete_LLongArrayND, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_uninitialize", _wrap_LLongArrayND_uninitialize, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_reshape", _wrap_LLongArrayND_reshape, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_valueAt", _wrap_LLongArrayND_valueAt, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_linearPtr", _wrap_LLongArrayND_linearPtr, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_convertLinearIndex", _wrap_LLongArrayND_convertLinearIndex, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_linearIndex", _wrap_LLongArrayND_linearIndex, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_length", _wrap_LLongArrayND_length, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_data", _wrap_LLongArrayND_data, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_isShapeKnown", _wrap_LLongArrayND_isShapeKnown, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_rank", _wrap_LLongArrayND_rank, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_shape", _wrap_LLongArrayND_shape, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_shapeData", _wrap_LLongArrayND_shapeData, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_fullRange", _wrap_LLongArrayND_fullRange, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_span", _wrap_LLongArrayND_span, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_maximumSpan", _wrap_LLongArrayND_maximumSpan, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_minimumSpan", _wrap_LLongArrayND_minimumSpan, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_strides", _wrap_LLongArrayND_strides, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_isZero", _wrap_LLongArrayND_isZero, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_isDensity", _wrap_LLongArrayND_isDensity, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND___pos__", _wrap_LLongArrayND___pos__, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND___neg__", _wrap_LLongArrayND___neg__, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_contract", _wrap_LLongArrayND_contract, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_transpose", _wrap_LLongArrayND_transpose, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_min", _wrap_LLongArrayND_min, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_max", _wrap_LLongArrayND_max, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_closestPtr", _wrap_LLongArrayND_closestPtr, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_interpolate1", _wrap_LLongArrayND_interpolate1, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_interpolate3", _wrap_LLongArrayND_interpolate3, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_constFill", _wrap_LLongArrayND_constFill, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_clear", _wrap_LLongArrayND_clear, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_linearFill", _wrap_LLongArrayND_linearFill, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_makeUnit", _wrap_LLongArrayND_makeUnit, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_makeNonNegative", _wrap_LLongArrayND_makeNonNegative, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_makeCopulaSteps", _wrap_LLongArrayND_makeCopulaSteps, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_isCompatible", _wrap_LLongArrayND_isCompatible, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_sliceShape", _wrap_LLongArrayND_sliceShape, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_ptr", _wrap_LLongArrayND_ptr, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_clPtr", _wrap_LLongArrayND_clPtr, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_classId", _wrap_LLongArrayND_classId, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_write", _wrap_LLongArrayND_write, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_classname", _wrap_LLongArrayND_classname, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_version", _wrap_LLongArrayND_version, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_restore", _wrap_LLongArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_setValue", _wrap_LLongArrayND_setValue, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_value", _wrap_LLongArrayND_value, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_setLinearValue", _wrap_LLongArrayND_setLinearValue, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_linearValue", _wrap_LLongArrayND_linearValue, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_setClosest", _wrap_LLongArrayND_setClosest, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_closest", _wrap_LLongArrayND_closest, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_set", _wrap_LLongArrayND_set, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND___call__", _wrap_LLongArrayND___call__, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_setCl", _wrap_LLongArrayND_setCl, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_cl", _wrap_LLongArrayND_cl, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_setData", _wrap_LLongArrayND_setData, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_maxAbsDifference", _wrap_LLongArrayND_maxAbsDifference, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND___eq__", _wrap_LLongArrayND___eq__, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND___ne__", _wrap_LLongArrayND___ne__, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND___add__", _wrap_LLongArrayND___add__, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND___sub__", _wrap_LLongArrayND___sub__, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND___mul__", _wrap_LLongArrayND___mul__, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND___div__", _wrap_LLongArrayND___div__, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND___imul__", _wrap_LLongArrayND___imul__, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND___idiv__", _wrap_LLongArrayND___idiv__, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND___iadd__", _wrap_LLongArrayND___iadd__, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND___isub__", _wrap_LLongArrayND___isub__, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_addmul", _wrap_LLongArrayND_addmul, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_inPlaceMul", _wrap_LLongArrayND_inPlaceMul, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_outer", _wrap_LLongArrayND_outer, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_dot", _wrap_LLongArrayND_dot, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_marginalize", _wrap_LLongArrayND_marginalize, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_sum", _wrap_LLongArrayND_sum, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_sumsq", _wrap_LLongArrayND_sumsq, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_derivative", _wrap_LLongArrayND_derivative, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_cdfArray", _wrap_LLongArrayND_cdfArray, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_cdfValue", _wrap_LLongArrayND_cdfValue, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_convertToLastDimCdf", _wrap_LLongArrayND_convertToLastDimCdf, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_isClose", _wrap_LLongArrayND_isClose, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_isShapeCompatible", _wrap_LLongArrayND_isShapeCompatible, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_exportSlice", _wrap_LLongArrayND_exportSlice, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_exportMemSlice", _wrap_LLongArrayND_exportMemSlice, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_importSlice", _wrap_LLongArrayND_importSlice, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_importMemSlice", _wrap_LLongArrayND_importMemSlice, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_multiplyBySlice", _wrap_LLongArrayND_multiplyBySlice, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_subrange", _wrap_LLongArrayND_subrange, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_slice", _wrap_LLongArrayND_slice, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_rotate", _wrap_LLongArrayND_rotate, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_exportSubrange", _wrap_LLongArrayND_exportSubrange, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_importSubrange", _wrap_LLongArrayND_importSubrange, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_multiMirror", _wrap_LLongArrayND_multiMirror, METH_VARARGS, NULL},
	{ (char *)"new_LLongArrayND", _wrap_new_LLongArrayND, METH_VARARGS, NULL},
	{ (char *)"LLongArrayND_swigregister", LLongArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_LLongArrayND", _wrap_new_ArchiveRecord_LLongArrayND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_LLongArrayND", _wrap_delete_ArchiveRecord_LLongArrayND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_LLongArrayND_swigregister", ArchiveRecord_LLongArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_LLongArrayND", _wrap_new_Ref_LLongArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongArrayND_restore", _wrap_Ref_LLongArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongArrayND_retrieve", _wrap_Ref_LLongArrayND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongArrayND_getValue", _wrap_Ref_LLongArrayND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_LLongArrayND", _wrap_delete_Ref_LLongArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongArrayND_swigregister", Ref_LLongArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_FloatArrayND", _wrap_delete_FloatArrayND, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_uninitialize", _wrap_FloatArrayND_uninitialize, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_reshape", _wrap_FloatArrayND_reshape, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_valueAt", _wrap_FloatArrayND_valueAt, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_linearPtr", _wrap_FloatArrayND_linearPtr, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_convertLinearIndex", _wrap_FloatArrayND_convertLinearIndex, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_linearIndex", _wrap_FloatArrayND_linearIndex, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_length", _wrap_FloatArrayND_length, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_data", _wrap_FloatArrayND_data, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_isShapeKnown", _wrap_FloatArrayND_isShapeKnown, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_rank", _wrap_FloatArrayND_rank, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_shape", _wrap_FloatArrayND_shape, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_shapeData", _wrap_FloatArrayND_shapeData, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_fullRange", _wrap_FloatArrayND_fullRange, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_span", _wrap_FloatArrayND_span, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_maximumSpan", _wrap_FloatArrayND_maximumSpan, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_minimumSpan", _wrap_FloatArrayND_minimumSpan, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_strides", _wrap_FloatArrayND_strides, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_isZero", _wrap_FloatArrayND_isZero, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_isDensity", _wrap_FloatArrayND_isDensity, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND___pos__", _wrap_FloatArrayND___pos__, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND___neg__", _wrap_FloatArrayND___neg__, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_contract", _wrap_FloatArrayND_contract, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_transpose", _wrap_FloatArrayND_transpose, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_min", _wrap_FloatArrayND_min, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_max", _wrap_FloatArrayND_max, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_closestPtr", _wrap_FloatArrayND_closestPtr, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_interpolate1", _wrap_FloatArrayND_interpolate1, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_interpolate3", _wrap_FloatArrayND_interpolate3, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_constFill", _wrap_FloatArrayND_constFill, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_clear", _wrap_FloatArrayND_clear, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_linearFill", _wrap_FloatArrayND_linearFill, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_makeUnit", _wrap_FloatArrayND_makeUnit, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_makeNonNegative", _wrap_FloatArrayND_makeNonNegative, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_makeCopulaSteps", _wrap_FloatArrayND_makeCopulaSteps, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_isCompatible", _wrap_FloatArrayND_isCompatible, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_sliceShape", _wrap_FloatArrayND_sliceShape, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_ptr", _wrap_FloatArrayND_ptr, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_clPtr", _wrap_FloatArrayND_clPtr, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_classId", _wrap_FloatArrayND_classId, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_write", _wrap_FloatArrayND_write, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_classname", _wrap_FloatArrayND_classname, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_version", _wrap_FloatArrayND_version, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_restore", _wrap_FloatArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_setValue", _wrap_FloatArrayND_setValue, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_value", _wrap_FloatArrayND_value, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_setLinearValue", _wrap_FloatArrayND_setLinearValue, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_linearValue", _wrap_FloatArrayND_linearValue, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_setClosest", _wrap_FloatArrayND_setClosest, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_closest", _wrap_FloatArrayND_closest, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_set", _wrap_FloatArrayND_set, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND___call__", _wrap_FloatArrayND___call__, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_setCl", _wrap_FloatArrayND_setCl, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_cl", _wrap_FloatArrayND_cl, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_setData", _wrap_FloatArrayND_setData, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_maxAbsDifference", _wrap_FloatArrayND_maxAbsDifference, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND___eq__", _wrap_FloatArrayND___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND___ne__", _wrap_FloatArrayND___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND___add__", _wrap_FloatArrayND___add__, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND___sub__", _wrap_FloatArrayND___sub__, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND___mul__", _wrap_FloatArrayND___mul__, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND___div__", _wrap_FloatArrayND___div__, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND___imul__", _wrap_FloatArrayND___imul__, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND___idiv__", _wrap_FloatArrayND___idiv__, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND___iadd__", _wrap_FloatArrayND___iadd__, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND___isub__", _wrap_FloatArrayND___isub__, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_addmul", _wrap_FloatArrayND_addmul, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_inPlaceMul", _wrap_FloatArrayND_inPlaceMul, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_outer", _wrap_FloatArrayND_outer, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_dot", _wrap_FloatArrayND_dot, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_marginalize", _wrap_FloatArrayND_marginalize, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_sum", _wrap_FloatArrayND_sum, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_sumsq", _wrap_FloatArrayND_sumsq, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_derivative", _wrap_FloatArrayND_derivative, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_cdfArray", _wrap_FloatArrayND_cdfArray, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_cdfValue", _wrap_FloatArrayND_cdfValue, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_convertToLastDimCdf", _wrap_FloatArrayND_convertToLastDimCdf, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_isClose", _wrap_FloatArrayND_isClose, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_isShapeCompatible", _wrap_FloatArrayND_isShapeCompatible, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_exportSlice", _wrap_FloatArrayND_exportSlice, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_exportMemSlice", _wrap_FloatArrayND_exportMemSlice, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_importSlice", _wrap_FloatArrayND_importSlice, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_importMemSlice", _wrap_FloatArrayND_importMemSlice, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_multiplyBySlice", _wrap_FloatArrayND_multiplyBySlice, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_subrange", _wrap_FloatArrayND_subrange, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_slice", _wrap_FloatArrayND_slice, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_rotate", _wrap_FloatArrayND_rotate, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_exportSubrange", _wrap_FloatArrayND_exportSubrange, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_importSubrange", _wrap_FloatArrayND_importSubrange, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_multiMirror", _wrap_FloatArrayND_multiMirror, METH_VARARGS, NULL},
	{ (char *)"new_FloatArrayND", _wrap_new_FloatArrayND, METH_VARARGS, NULL},
	{ (char *)"FloatArrayND_swigregister", FloatArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_FloatArrayND", _wrap_new_ArchiveRecord_FloatArrayND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_FloatArrayND", _wrap_delete_ArchiveRecord_FloatArrayND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_FloatArrayND_swigregister", ArchiveRecord_FloatArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_FloatArrayND", _wrap_new_Ref_FloatArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatArrayND_restore", _wrap_Ref_FloatArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatArrayND_retrieve", _wrap_Ref_FloatArrayND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatArrayND_getValue", _wrap_Ref_FloatArrayND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_FloatArrayND", _wrap_delete_Ref_FloatArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatArrayND_swigregister", Ref_FloatArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleArrayND", _wrap_delete_DoubleArrayND, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_uninitialize", _wrap_DoubleArrayND_uninitialize, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_reshape", _wrap_DoubleArrayND_reshape, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_valueAt", _wrap_DoubleArrayND_valueAt, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_linearPtr", _wrap_DoubleArrayND_linearPtr, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_convertLinearIndex", _wrap_DoubleArrayND_convertLinearIndex, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_linearIndex", _wrap_DoubleArrayND_linearIndex, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_length", _wrap_DoubleArrayND_length, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_data", _wrap_DoubleArrayND_data, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_isShapeKnown", _wrap_DoubleArrayND_isShapeKnown, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_rank", _wrap_DoubleArrayND_rank, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_shape", _wrap_DoubleArrayND_shape, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_shapeData", _wrap_DoubleArrayND_shapeData, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_fullRange", _wrap_DoubleArrayND_fullRange, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_span", _wrap_DoubleArrayND_span, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_maximumSpan", _wrap_DoubleArrayND_maximumSpan, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_minimumSpan", _wrap_DoubleArrayND_minimumSpan, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_strides", _wrap_DoubleArrayND_strides, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_isZero", _wrap_DoubleArrayND_isZero, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_isDensity", _wrap_DoubleArrayND_isDensity, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND___pos__", _wrap_DoubleArrayND___pos__, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND___neg__", _wrap_DoubleArrayND___neg__, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_contract", _wrap_DoubleArrayND_contract, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_transpose", _wrap_DoubleArrayND_transpose, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_min", _wrap_DoubleArrayND_min, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_max", _wrap_DoubleArrayND_max, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_closestPtr", _wrap_DoubleArrayND_closestPtr, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_interpolate1", _wrap_DoubleArrayND_interpolate1, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_interpolate3", _wrap_DoubleArrayND_interpolate3, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_constFill", _wrap_DoubleArrayND_constFill, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_clear", _wrap_DoubleArrayND_clear, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_linearFill", _wrap_DoubleArrayND_linearFill, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_makeUnit", _wrap_DoubleArrayND_makeUnit, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_makeNonNegative", _wrap_DoubleArrayND_makeNonNegative, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_makeCopulaSteps", _wrap_DoubleArrayND_makeCopulaSteps, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_isCompatible", _wrap_DoubleArrayND_isCompatible, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_sliceShape", _wrap_DoubleArrayND_sliceShape, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_ptr", _wrap_DoubleArrayND_ptr, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_clPtr", _wrap_DoubleArrayND_clPtr, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_classId", _wrap_DoubleArrayND_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_write", _wrap_DoubleArrayND_write, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_classname", _wrap_DoubleArrayND_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_version", _wrap_DoubleArrayND_version, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_restore", _wrap_DoubleArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_setValue", _wrap_DoubleArrayND_setValue, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_value", _wrap_DoubleArrayND_value, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_setLinearValue", _wrap_DoubleArrayND_setLinearValue, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_linearValue", _wrap_DoubleArrayND_linearValue, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_setClosest", _wrap_DoubleArrayND_setClosest, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_closest", _wrap_DoubleArrayND_closest, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_set", _wrap_DoubleArrayND_set, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND___call__", _wrap_DoubleArrayND___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_setCl", _wrap_DoubleArrayND_setCl, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_cl", _wrap_DoubleArrayND_cl, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_setData", _wrap_DoubleArrayND_setData, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_maxAbsDifference", _wrap_DoubleArrayND_maxAbsDifference, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND___eq__", _wrap_DoubleArrayND___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND___ne__", _wrap_DoubleArrayND___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND___add__", _wrap_DoubleArrayND___add__, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND___sub__", _wrap_DoubleArrayND___sub__, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND___mul__", _wrap_DoubleArrayND___mul__, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND___div__", _wrap_DoubleArrayND___div__, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND___imul__", _wrap_DoubleArrayND___imul__, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND___idiv__", _wrap_DoubleArrayND___idiv__, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND___iadd__", _wrap_DoubleArrayND___iadd__, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND___isub__", _wrap_DoubleArrayND___isub__, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_addmul", _wrap_DoubleArrayND_addmul, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_inPlaceMul", _wrap_DoubleArrayND_inPlaceMul, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_outer", _wrap_DoubleArrayND_outer, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_dot", _wrap_DoubleArrayND_dot, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_marginalize", _wrap_DoubleArrayND_marginalize, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_sum", _wrap_DoubleArrayND_sum, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_sumsq", _wrap_DoubleArrayND_sumsq, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_derivative", _wrap_DoubleArrayND_derivative, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_cdfArray", _wrap_DoubleArrayND_cdfArray, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_cdfValue", _wrap_DoubleArrayND_cdfValue, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_convertToLastDimCdf", _wrap_DoubleArrayND_convertToLastDimCdf, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_isClose", _wrap_DoubleArrayND_isClose, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_isShapeCompatible", _wrap_DoubleArrayND_isShapeCompatible, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_exportSlice", _wrap_DoubleArrayND_exportSlice, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_exportMemSlice", _wrap_DoubleArrayND_exportMemSlice, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_importSlice", _wrap_DoubleArrayND_importSlice, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_importMemSlice", _wrap_DoubleArrayND_importMemSlice, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_multiplyBySlice", _wrap_DoubleArrayND_multiplyBySlice, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_subrange", _wrap_DoubleArrayND_subrange, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_slice", _wrap_DoubleArrayND_slice, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_rotate", _wrap_DoubleArrayND_rotate, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_exportSubrange", _wrap_DoubleArrayND_exportSubrange, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_importSubrange", _wrap_DoubleArrayND_importSubrange, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_multiMirror", _wrap_DoubleArrayND_multiMirror, METH_VARARGS, NULL},
	{ (char *)"new_DoubleArrayND", _wrap_new_DoubleArrayND, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayND_swigregister", DoubleArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DoubleArrayND", _wrap_new_ArchiveRecord_DoubleArrayND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DoubleArrayND", _wrap_delete_ArchiveRecord_DoubleArrayND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DoubleArrayND_swigregister", ArchiveRecord_DoubleArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DoubleArrayND", _wrap_new_Ref_DoubleArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleArrayND_restore", _wrap_Ref_DoubleArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleArrayND_retrieve", _wrap_Ref_DoubleArrayND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleArrayND_getValue", _wrap_Ref_DoubleArrayND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DoubleArrayND", _wrap_delete_Ref_DoubleArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleArrayND_swigregister", Ref_DoubleArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_CFloatArrayND", _wrap_delete_CFloatArrayND, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_uninitialize", _wrap_CFloatArrayND_uninitialize, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_reshape", _wrap_CFloatArrayND_reshape, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_valueAt", _wrap_CFloatArrayND_valueAt, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_linearPtr", _wrap_CFloatArrayND_linearPtr, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_convertLinearIndex", _wrap_CFloatArrayND_convertLinearIndex, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_linearIndex", _wrap_CFloatArrayND_linearIndex, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_length", _wrap_CFloatArrayND_length, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_data", _wrap_CFloatArrayND_data, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_isShapeKnown", _wrap_CFloatArrayND_isShapeKnown, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_rank", _wrap_CFloatArrayND_rank, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_shape", _wrap_CFloatArrayND_shape, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_shapeData", _wrap_CFloatArrayND_shapeData, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_fullRange", _wrap_CFloatArrayND_fullRange, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_span", _wrap_CFloatArrayND_span, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_maximumSpan", _wrap_CFloatArrayND_maximumSpan, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_minimumSpan", _wrap_CFloatArrayND_minimumSpan, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_strides", _wrap_CFloatArrayND_strides, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_isZero", _wrap_CFloatArrayND_isZero, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_isDensity", _wrap_CFloatArrayND_isDensity, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND___pos__", _wrap_CFloatArrayND___pos__, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND___neg__", _wrap_CFloatArrayND___neg__, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_contract", _wrap_CFloatArrayND_contract, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_transpose", _wrap_CFloatArrayND_transpose, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_min", _wrap_CFloatArrayND_min, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_max", _wrap_CFloatArrayND_max, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_closestPtr", _wrap_CFloatArrayND_closestPtr, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_interpolate1", _wrap_CFloatArrayND_interpolate1, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_interpolate3", _wrap_CFloatArrayND_interpolate3, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_constFill", _wrap_CFloatArrayND_constFill, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_clear", _wrap_CFloatArrayND_clear, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_linearFill", _wrap_CFloatArrayND_linearFill, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_makeUnit", _wrap_CFloatArrayND_makeUnit, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_makeNonNegative", _wrap_CFloatArrayND_makeNonNegative, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_makeCopulaSteps", _wrap_CFloatArrayND_makeCopulaSteps, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_isCompatible", _wrap_CFloatArrayND_isCompatible, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_sliceShape", _wrap_CFloatArrayND_sliceShape, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_ptr", _wrap_CFloatArrayND_ptr, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_clPtr", _wrap_CFloatArrayND_clPtr, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_classId", _wrap_CFloatArrayND_classId, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_write", _wrap_CFloatArrayND_write, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_classname", _wrap_CFloatArrayND_classname, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_version", _wrap_CFloatArrayND_version, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_restore", _wrap_CFloatArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_setValue", _wrap_CFloatArrayND_setValue, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_value", _wrap_CFloatArrayND_value, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_setLinearValue", _wrap_CFloatArrayND_setLinearValue, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_linearValue", _wrap_CFloatArrayND_linearValue, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_setClosest", _wrap_CFloatArrayND_setClosest, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_closest", _wrap_CFloatArrayND_closest, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_set", _wrap_CFloatArrayND_set, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND___call__", _wrap_CFloatArrayND___call__, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_setCl", _wrap_CFloatArrayND_setCl, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_cl", _wrap_CFloatArrayND_cl, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_setData", _wrap_CFloatArrayND_setData, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_maxAbsDifference", _wrap_CFloatArrayND_maxAbsDifference, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND___eq__", _wrap_CFloatArrayND___eq__, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND___ne__", _wrap_CFloatArrayND___ne__, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND___add__", _wrap_CFloatArrayND___add__, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND___sub__", _wrap_CFloatArrayND___sub__, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND___mul__", _wrap_CFloatArrayND___mul__, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND___div__", _wrap_CFloatArrayND___div__, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND___imul__", _wrap_CFloatArrayND___imul__, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND___idiv__", _wrap_CFloatArrayND___idiv__, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND___iadd__", _wrap_CFloatArrayND___iadd__, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND___isub__", _wrap_CFloatArrayND___isub__, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_addmul", _wrap_CFloatArrayND_addmul, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_inPlaceMul", _wrap_CFloatArrayND_inPlaceMul, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_outer", _wrap_CFloatArrayND_outer, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_dot", _wrap_CFloatArrayND_dot, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_marginalize", _wrap_CFloatArrayND_marginalize, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_sum", _wrap_CFloatArrayND_sum, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_sumsq", _wrap_CFloatArrayND_sumsq, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_derivative", _wrap_CFloatArrayND_derivative, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_cdfArray", _wrap_CFloatArrayND_cdfArray, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_cdfValue", _wrap_CFloatArrayND_cdfValue, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_convertToLastDimCdf", _wrap_CFloatArrayND_convertToLastDimCdf, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_isClose", _wrap_CFloatArrayND_isClose, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_isShapeCompatible", _wrap_CFloatArrayND_isShapeCompatible, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_exportSlice", _wrap_CFloatArrayND_exportSlice, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_exportMemSlice", _wrap_CFloatArrayND_exportMemSlice, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_importSlice", _wrap_CFloatArrayND_importSlice, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_importMemSlice", _wrap_CFloatArrayND_importMemSlice, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_multiplyBySlice", _wrap_CFloatArrayND_multiplyBySlice, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_subrange", _wrap_CFloatArrayND_subrange, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_slice", _wrap_CFloatArrayND_slice, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_rotate", _wrap_CFloatArrayND_rotate, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_exportSubrange", _wrap_CFloatArrayND_exportSubrange, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_importSubrange", _wrap_CFloatArrayND_importSubrange, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_multiMirror", _wrap_CFloatArrayND_multiMirror, METH_VARARGS, NULL},
	{ (char *)"new_CFloatArrayND", _wrap_new_CFloatArrayND, METH_VARARGS, NULL},
	{ (char *)"CFloatArrayND_swigregister", CFloatArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_CDoubleArrayND", _wrap_delete_CDoubleArrayND, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_uninitialize", _wrap_CDoubleArrayND_uninitialize, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_reshape", _wrap_CDoubleArrayND_reshape, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_valueAt", _wrap_CDoubleArrayND_valueAt, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_linearPtr", _wrap_CDoubleArrayND_linearPtr, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_convertLinearIndex", _wrap_CDoubleArrayND_convertLinearIndex, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_linearIndex", _wrap_CDoubleArrayND_linearIndex, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_length", _wrap_CDoubleArrayND_length, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_data", _wrap_CDoubleArrayND_data, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_isShapeKnown", _wrap_CDoubleArrayND_isShapeKnown, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_rank", _wrap_CDoubleArrayND_rank, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_shape", _wrap_CDoubleArrayND_shape, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_shapeData", _wrap_CDoubleArrayND_shapeData, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_fullRange", _wrap_CDoubleArrayND_fullRange, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_span", _wrap_CDoubleArrayND_span, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_maximumSpan", _wrap_CDoubleArrayND_maximumSpan, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_minimumSpan", _wrap_CDoubleArrayND_minimumSpan, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_strides", _wrap_CDoubleArrayND_strides, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_isZero", _wrap_CDoubleArrayND_isZero, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_isDensity", _wrap_CDoubleArrayND_isDensity, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND___pos__", _wrap_CDoubleArrayND___pos__, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND___neg__", _wrap_CDoubleArrayND___neg__, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_contract", _wrap_CDoubleArrayND_contract, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_transpose", _wrap_CDoubleArrayND_transpose, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_min", _wrap_CDoubleArrayND_min, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_max", _wrap_CDoubleArrayND_max, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_closestPtr", _wrap_CDoubleArrayND_closestPtr, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_interpolate1", _wrap_CDoubleArrayND_interpolate1, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_interpolate3", _wrap_CDoubleArrayND_interpolate3, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_constFill", _wrap_CDoubleArrayND_constFill, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_clear", _wrap_CDoubleArrayND_clear, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_linearFill", _wrap_CDoubleArrayND_linearFill, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_makeUnit", _wrap_CDoubleArrayND_makeUnit, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_makeNonNegative", _wrap_CDoubleArrayND_makeNonNegative, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_makeCopulaSteps", _wrap_CDoubleArrayND_makeCopulaSteps, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_isCompatible", _wrap_CDoubleArrayND_isCompatible, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_sliceShape", _wrap_CDoubleArrayND_sliceShape, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_ptr", _wrap_CDoubleArrayND_ptr, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_clPtr", _wrap_CDoubleArrayND_clPtr, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_classId", _wrap_CDoubleArrayND_classId, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_write", _wrap_CDoubleArrayND_write, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_classname", _wrap_CDoubleArrayND_classname, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_version", _wrap_CDoubleArrayND_version, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_restore", _wrap_CDoubleArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_setValue", _wrap_CDoubleArrayND_setValue, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_value", _wrap_CDoubleArrayND_value, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_setLinearValue", _wrap_CDoubleArrayND_setLinearValue, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_linearValue", _wrap_CDoubleArrayND_linearValue, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_setClosest", _wrap_CDoubleArrayND_setClosest, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_closest", _wrap_CDoubleArrayND_closest, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_set", _wrap_CDoubleArrayND_set, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND___call__", _wrap_CDoubleArrayND___call__, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_setCl", _wrap_CDoubleArrayND_setCl, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_cl", _wrap_CDoubleArrayND_cl, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_setData", _wrap_CDoubleArrayND_setData, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_maxAbsDifference", _wrap_CDoubleArrayND_maxAbsDifference, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND___eq__", _wrap_CDoubleArrayND___eq__, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND___ne__", _wrap_CDoubleArrayND___ne__, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND___add__", _wrap_CDoubleArrayND___add__, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND___sub__", _wrap_CDoubleArrayND___sub__, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND___mul__", _wrap_CDoubleArrayND___mul__, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND___div__", _wrap_CDoubleArrayND___div__, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND___imul__", _wrap_CDoubleArrayND___imul__, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND___idiv__", _wrap_CDoubleArrayND___idiv__, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND___iadd__", _wrap_CDoubleArrayND___iadd__, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND___isub__", _wrap_CDoubleArrayND___isub__, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_addmul", _wrap_CDoubleArrayND_addmul, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_inPlaceMul", _wrap_CDoubleArrayND_inPlaceMul, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_outer", _wrap_CDoubleArrayND_outer, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_dot", _wrap_CDoubleArrayND_dot, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_marginalize", _wrap_CDoubleArrayND_marginalize, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_sum", _wrap_CDoubleArrayND_sum, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_sumsq", _wrap_CDoubleArrayND_sumsq, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_derivative", _wrap_CDoubleArrayND_derivative, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_cdfArray", _wrap_CDoubleArrayND_cdfArray, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_cdfValue", _wrap_CDoubleArrayND_cdfValue, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_convertToLastDimCdf", _wrap_CDoubleArrayND_convertToLastDimCdf, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_isClose", _wrap_CDoubleArrayND_isClose, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_isShapeCompatible", _wrap_CDoubleArrayND_isShapeCompatible, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_exportSlice", _wrap_CDoubleArrayND_exportSlice, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_exportMemSlice", _wrap_CDoubleArrayND_exportMemSlice, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_importSlice", _wrap_CDoubleArrayND_importSlice, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_importMemSlice", _wrap_CDoubleArrayND_importMemSlice, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_multiplyBySlice", _wrap_CDoubleArrayND_multiplyBySlice, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_subrange", _wrap_CDoubleArrayND_subrange, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_slice", _wrap_CDoubleArrayND_slice, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_rotate", _wrap_CDoubleArrayND_rotate, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_exportSubrange", _wrap_CDoubleArrayND_exportSubrange, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_importSubrange", _wrap_CDoubleArrayND_importSubrange, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_multiMirror", _wrap_CDoubleArrayND_multiMirror, METH_VARARGS, NULL},
	{ (char *)"new_CDoubleArrayND", _wrap_new_CDoubleArrayND, METH_VARARGS, NULL},
	{ (char *)"CDoubleArrayND_swigregister", CDoubleArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_CFloatArrayND", _wrap_new_ArchiveRecord_CFloatArrayND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_CFloatArrayND", _wrap_delete_ArchiveRecord_CFloatArrayND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_CFloatArrayND_swigregister", ArchiveRecord_CFloatArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_CFloatArrayND", _wrap_new_Ref_CFloatArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_CFloatArrayND_restore", _wrap_Ref_CFloatArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_CFloatArrayND_retrieve", _wrap_Ref_CFloatArrayND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_CFloatArrayND_getValue", _wrap_Ref_CFloatArrayND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_CFloatArrayND", _wrap_delete_Ref_CFloatArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_CFloatArrayND_swigregister", Ref_CFloatArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_CDoubleArrayND", _wrap_new_ArchiveRecord_CDoubleArrayND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_CDoubleArrayND", _wrap_delete_ArchiveRecord_CDoubleArrayND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_CDoubleArrayND_swigregister", ArchiveRecord_CDoubleArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_CDoubleArrayND", _wrap_new_Ref_CDoubleArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_CDoubleArrayND_restore", _wrap_Ref_CDoubleArrayND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_CDoubleArrayND_retrieve", _wrap_Ref_CDoubleArrayND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_CDoubleArrayND_getValue", _wrap_Ref_CDoubleArrayND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_CDoubleArrayND", _wrap_delete_Ref_CDoubleArrayND, METH_VARARGS, NULL},
	{ (char *)"Ref_CDoubleArrayND_swigregister", Ref_CDoubleArrayND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LinearMapper1d", _wrap_new_LinearMapper1d, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1d___call__", _wrap_LinearMapper1d___call__, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1d_a", _wrap_LinearMapper1d_a, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1d_b", _wrap_LinearMapper1d_b, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1d_inverse", _wrap_LinearMapper1d_inverse, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1d___mul__", _wrap_LinearMapper1d___mul__, METH_VARARGS, NULL},
	{ (char *)"delete_LinearMapper1d", _wrap_delete_LinearMapper1d, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1d_swigregister", LinearMapper1d_swigregister, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_iterator", _wrap_LinearMapper1dVector_iterator, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector___nonzero__", _wrap_LinearMapper1dVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector___bool__", _wrap_LinearMapper1dVector___bool__, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector___len__", _wrap_LinearMapper1dVector___len__, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector___getslice__", _wrap_LinearMapper1dVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector___setslice__", _wrap_LinearMapper1dVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector___delslice__", _wrap_LinearMapper1dVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector___delitem__", _wrap_LinearMapper1dVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector___getitem__", _wrap_LinearMapper1dVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector___setitem__", _wrap_LinearMapper1dVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_pop", _wrap_LinearMapper1dVector_pop, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_append", _wrap_LinearMapper1dVector_append, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_empty", _wrap_LinearMapper1dVector_empty, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_size", _wrap_LinearMapper1dVector_size, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_swap", _wrap_LinearMapper1dVector_swap, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_begin", _wrap_LinearMapper1dVector_begin, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_end", _wrap_LinearMapper1dVector_end, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_rbegin", _wrap_LinearMapper1dVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_rend", _wrap_LinearMapper1dVector_rend, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_clear", _wrap_LinearMapper1dVector_clear, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_get_allocator", _wrap_LinearMapper1dVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_pop_back", _wrap_LinearMapper1dVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_erase", _wrap_LinearMapper1dVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_LinearMapper1dVector", _wrap_new_LinearMapper1dVector, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_push_back", _wrap_LinearMapper1dVector_push_back, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_front", _wrap_LinearMapper1dVector_front, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_back", _wrap_LinearMapper1dVector_back, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_assign", _wrap_LinearMapper1dVector_assign, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_resize", _wrap_LinearMapper1dVector_resize, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_insert", _wrap_LinearMapper1dVector_insert, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_reserve", _wrap_LinearMapper1dVector_reserve, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_capacity", _wrap_LinearMapper1dVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_LinearMapper1dVector", _wrap_delete_LinearMapper1dVector, METH_VARARGS, NULL},
	{ (char *)"LinearMapper1dVector_swigregister", LinearMapper1dVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_CircularMapper1d", _wrap_new_CircularMapper1d, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1d___call__", _wrap_CircularMapper1d___call__, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1d_a", _wrap_CircularMapper1d_a, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1d_b", _wrap_CircularMapper1d_b, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1d_period", _wrap_CircularMapper1d_period, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1d_linearMapper", _wrap_CircularMapper1d_linearMapper, METH_VARARGS, NULL},
	{ (char *)"delete_CircularMapper1d", _wrap_delete_CircularMapper1d, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1d_swigregister", CircularMapper1d_swigregister, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_iterator", _wrap_CircularMapper1dVector_iterator, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector___nonzero__", _wrap_CircularMapper1dVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector___bool__", _wrap_CircularMapper1dVector___bool__, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector___len__", _wrap_CircularMapper1dVector___len__, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector___getslice__", _wrap_CircularMapper1dVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector___setslice__", _wrap_CircularMapper1dVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector___delslice__", _wrap_CircularMapper1dVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector___delitem__", _wrap_CircularMapper1dVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector___getitem__", _wrap_CircularMapper1dVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector___setitem__", _wrap_CircularMapper1dVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_pop", _wrap_CircularMapper1dVector_pop, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_append", _wrap_CircularMapper1dVector_append, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_empty", _wrap_CircularMapper1dVector_empty, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_size", _wrap_CircularMapper1dVector_size, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_swap", _wrap_CircularMapper1dVector_swap, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_begin", _wrap_CircularMapper1dVector_begin, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_end", _wrap_CircularMapper1dVector_end, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_rbegin", _wrap_CircularMapper1dVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_rend", _wrap_CircularMapper1dVector_rend, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_clear", _wrap_CircularMapper1dVector_clear, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_get_allocator", _wrap_CircularMapper1dVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_pop_back", _wrap_CircularMapper1dVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_erase", _wrap_CircularMapper1dVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_CircularMapper1dVector", _wrap_new_CircularMapper1dVector, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_push_back", _wrap_CircularMapper1dVector_push_back, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_front", _wrap_CircularMapper1dVector_front, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_back", _wrap_CircularMapper1dVector_back, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_assign", _wrap_CircularMapper1dVector_assign, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_resize", _wrap_CircularMapper1dVector_resize, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_insert", _wrap_CircularMapper1dVector_insert, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_reserve", _wrap_CircularMapper1dVector_reserve, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_capacity", _wrap_CircularMapper1dVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_CircularMapper1dVector", _wrap_delete_CircularMapper1dVector, METH_VARARGS, NULL},
	{ (char *)"CircularMapper1dVector_swigregister", CircularMapper1dVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_min", _wrap_HistoAxis_min, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_max", _wrap_HistoAxis_max, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_interval", _wrap_HistoAxis_interval, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_length", _wrap_HistoAxis_length, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_nBins", _wrap_HistoAxis_nBins, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_binWidth", _wrap_HistoAxis_binWidth, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_label", _wrap_HistoAxis_label, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_isUniform", _wrap_HistoAxis_isUniform, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_binCenter", _wrap_HistoAxis_binCenter, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_leftBinEdge", _wrap_HistoAxis_leftBinEdge, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_rightBinEdge", _wrap_HistoAxis_rightBinEdge, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_binInterval", _wrap_HistoAxis_binInterval, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_setLabel", _wrap_HistoAxis_setLabel, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_binNumber", _wrap_HistoAxis_binNumber, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_closestValidBin", _wrap_HistoAxis_closestValidBin, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_binNumberMapper", _wrap_HistoAxis_binNumberMapper, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_fltBinNumber", _wrap_HistoAxis_fltBinNumber, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_kernelScanMapper", _wrap_HistoAxis_kernelScanMapper, METH_VARARGS, NULL},
	{ (char *)"HistoAxis___eq__", _wrap_HistoAxis___eq__, METH_VARARGS, NULL},
	{ (char *)"HistoAxis___ne__", _wrap_HistoAxis___ne__, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_isClose", _wrap_HistoAxis_isClose, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_rebin", _wrap_HistoAxis_rebin, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_classId", _wrap_HistoAxis_classId, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_write", _wrap_HistoAxis_write, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_classname", _wrap_HistoAxis_classname, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_version", _wrap_HistoAxis_version, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_read", _wrap_HistoAxis_read, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_range", _wrap_HistoAxis_range, METH_VARARGS, NULL},
	{ (char *)"new_HistoAxis", _wrap_new_HistoAxis, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_binCenters", _wrap_HistoAxis_binCenters, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_binEdges", _wrap_HistoAxis_binEdges, METH_VARARGS, NULL},
	{ (char *)"delete_HistoAxis", _wrap_delete_HistoAxis, METH_VARARGS, NULL},
	{ (char *)"HistoAxis_swigregister", HistoAxis_swigregister, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_iterator", _wrap_HistoAxisVector_iterator, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector___nonzero__", _wrap_HistoAxisVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector___bool__", _wrap_HistoAxisVector___bool__, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector___len__", _wrap_HistoAxisVector___len__, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector___getslice__", _wrap_HistoAxisVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector___setslice__", _wrap_HistoAxisVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector___delslice__", _wrap_HistoAxisVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector___delitem__", _wrap_HistoAxisVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector___getitem__", _wrap_HistoAxisVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector___setitem__", _wrap_HistoAxisVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_pop", _wrap_HistoAxisVector_pop, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_append", _wrap_HistoAxisVector_append, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_empty", _wrap_HistoAxisVector_empty, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_size", _wrap_HistoAxisVector_size, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_swap", _wrap_HistoAxisVector_swap, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_begin", _wrap_HistoAxisVector_begin, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_end", _wrap_HistoAxisVector_end, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_rbegin", _wrap_HistoAxisVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_rend", _wrap_HistoAxisVector_rend, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_clear", _wrap_HistoAxisVector_clear, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_get_allocator", _wrap_HistoAxisVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_pop_back", _wrap_HistoAxisVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_erase", _wrap_HistoAxisVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_HistoAxisVector", _wrap_new_HistoAxisVector, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_push_back", _wrap_HistoAxisVector_push_back, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_front", _wrap_HistoAxisVector_front, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_back", _wrap_HistoAxisVector_back, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_assign", _wrap_HistoAxisVector_assign, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_resize", _wrap_HistoAxisVector_resize, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_insert", _wrap_HistoAxisVector_insert, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_reserve", _wrap_HistoAxisVector_reserve, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_capacity", _wrap_HistoAxisVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_HistoAxisVector", _wrap_delete_HistoAxisVector, METH_VARARGS, NULL},
	{ (char *)"HistoAxisVector_swigregister", HistoAxisVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_min", _wrap_NUHistoAxis_min, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_max", _wrap_NUHistoAxis_max, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_interval", _wrap_NUHistoAxis_interval, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_length", _wrap_NUHistoAxis_length, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_nBins", _wrap_NUHistoAxis_nBins, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_binWidth", _wrap_NUHistoAxis_binWidth, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_label", _wrap_NUHistoAxis_label, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_isUniform", _wrap_NUHistoAxis_isUniform, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_leftBinEdge", _wrap_NUHistoAxis_leftBinEdge, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_rightBinEdge", _wrap_NUHistoAxis_rightBinEdge, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_binCenter", _wrap_NUHistoAxis_binCenter, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_binInterval", _wrap_NUHistoAxis_binInterval, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_setLabel", _wrap_NUHistoAxis_setLabel, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_binNumber", _wrap_NUHistoAxis_binNumber, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_fltBinNumber", _wrap_NUHistoAxis_fltBinNumber, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_closestValidBin", _wrap_NUHistoAxis_closestValidBin, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis___eq__", _wrap_NUHistoAxis___eq__, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis___ne__", _wrap_NUHistoAxis___ne__, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_isClose", _wrap_NUHistoAxis_isClose, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_rebin", _wrap_NUHistoAxis_rebin, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_classId", _wrap_NUHistoAxis_classId, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_write", _wrap_NUHistoAxis_write, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_classname", _wrap_NUHistoAxis_classname, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_version", _wrap_NUHistoAxis_version, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_read", _wrap_NUHistoAxis_read, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_range", _wrap_NUHistoAxis_range, METH_VARARGS, NULL},
	{ (char *)"new_NUHistoAxis", _wrap_new_NUHistoAxis, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_binCenters", _wrap_NUHistoAxis_binCenters, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_binEdges", _wrap_NUHistoAxis_binEdges, METH_VARARGS, NULL},
	{ (char *)"delete_NUHistoAxis", _wrap_delete_NUHistoAxis, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxis_swigregister", NUHistoAxis_swigregister, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_iterator", _wrap_NUHistoAxisVector_iterator, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector___nonzero__", _wrap_NUHistoAxisVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector___bool__", _wrap_NUHistoAxisVector___bool__, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector___len__", _wrap_NUHistoAxisVector___len__, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector___getslice__", _wrap_NUHistoAxisVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector___setslice__", _wrap_NUHistoAxisVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector___delslice__", _wrap_NUHistoAxisVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector___delitem__", _wrap_NUHistoAxisVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector___getitem__", _wrap_NUHistoAxisVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector___setitem__", _wrap_NUHistoAxisVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_pop", _wrap_NUHistoAxisVector_pop, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_append", _wrap_NUHistoAxisVector_append, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_empty", _wrap_NUHistoAxisVector_empty, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_size", _wrap_NUHistoAxisVector_size, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_swap", _wrap_NUHistoAxisVector_swap, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_begin", _wrap_NUHistoAxisVector_begin, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_end", _wrap_NUHistoAxisVector_end, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_rbegin", _wrap_NUHistoAxisVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_rend", _wrap_NUHistoAxisVector_rend, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_clear", _wrap_NUHistoAxisVector_clear, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_get_allocator", _wrap_NUHistoAxisVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_pop_back", _wrap_NUHistoAxisVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_erase", _wrap_NUHistoAxisVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_NUHistoAxisVector", _wrap_new_NUHistoAxisVector, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_push_back", _wrap_NUHistoAxisVector_push_back, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_front", _wrap_NUHistoAxisVector_front, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_back", _wrap_NUHistoAxisVector_back, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_assign", _wrap_NUHistoAxisVector_assign, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_resize", _wrap_NUHistoAxisVector_resize, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_insert", _wrap_NUHistoAxisVector_insert, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_reserve", _wrap_NUHistoAxisVector_reserve, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_capacity", _wrap_NUHistoAxisVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_NUHistoAxisVector", _wrap_delete_NUHistoAxisVector, METH_VARARGS, NULL},
	{ (char *)"NUHistoAxisVector_swigregister", NUHistoAxisVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_isUniform", _wrap_DualHistoAxis_isUniform, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_min", _wrap_DualHistoAxis_min, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_max", _wrap_DualHistoAxis_max, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_interval", _wrap_DualHistoAxis_interval, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_length", _wrap_DualHistoAxis_length, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_nBins", _wrap_DualHistoAxis_nBins, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_binWidth", _wrap_DualHistoAxis_binWidth, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_label", _wrap_DualHistoAxis_label, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_binCenter", _wrap_DualHistoAxis_binCenter, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_leftBinEdge", _wrap_DualHistoAxis_leftBinEdge, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_rightBinEdge", _wrap_DualHistoAxis_rightBinEdge, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_binInterval", _wrap_DualHistoAxis_binInterval, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_getNUHistoAxis", _wrap_DualHistoAxis_getNUHistoAxis, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_getHistoAxis", _wrap_DualHistoAxis_getHistoAxis, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_setLabel", _wrap_DualHistoAxis_setLabel, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_binNumber", _wrap_DualHistoAxis_binNumber, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_fltBinNumber", _wrap_DualHistoAxis_fltBinNumber, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_closestValidBin", _wrap_DualHistoAxis_closestValidBin, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis___eq__", _wrap_DualHistoAxis___eq__, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis___ne__", _wrap_DualHistoAxis___ne__, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_isClose", _wrap_DualHistoAxis_isClose, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_rebin", _wrap_DualHistoAxis_rebin, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_classId", _wrap_DualHistoAxis_classId, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_write", _wrap_DualHistoAxis_write, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_classname", _wrap_DualHistoAxis_classname, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_version", _wrap_DualHistoAxis_version, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_read", _wrap_DualHistoAxis_read, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_range", _wrap_DualHistoAxis_range, METH_VARARGS, NULL},
	{ (char *)"new_DualHistoAxis", _wrap_new_DualHistoAxis, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_binCenters", _wrap_DualHistoAxis_binCenters, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_binEdges", _wrap_DualHistoAxis_binEdges, METH_VARARGS, NULL},
	{ (char *)"delete_DualHistoAxis", _wrap_delete_DualHistoAxis, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxis_swigregister", DualHistoAxis_swigregister, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_iterator", _wrap_DualHistoAxisVector_iterator, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector___nonzero__", _wrap_DualHistoAxisVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector___bool__", _wrap_DualHistoAxisVector___bool__, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector___len__", _wrap_DualHistoAxisVector___len__, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector___getslice__", _wrap_DualHistoAxisVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector___setslice__", _wrap_DualHistoAxisVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector___delslice__", _wrap_DualHistoAxisVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector___delitem__", _wrap_DualHistoAxisVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector___getitem__", _wrap_DualHistoAxisVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector___setitem__", _wrap_DualHistoAxisVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_pop", _wrap_DualHistoAxisVector_pop, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_append", _wrap_DualHistoAxisVector_append, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_empty", _wrap_DualHistoAxisVector_empty, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_size", _wrap_DualHistoAxisVector_size, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_swap", _wrap_DualHistoAxisVector_swap, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_begin", _wrap_DualHistoAxisVector_begin, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_end", _wrap_DualHistoAxisVector_end, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_rbegin", _wrap_DualHistoAxisVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_rend", _wrap_DualHistoAxisVector_rend, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_clear", _wrap_DualHistoAxisVector_clear, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_get_allocator", _wrap_DualHistoAxisVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_pop_back", _wrap_DualHistoAxisVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_erase", _wrap_DualHistoAxisVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_DualHistoAxisVector", _wrap_new_DualHistoAxisVector, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_push_back", _wrap_DualHistoAxisVector_push_back, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_front", _wrap_DualHistoAxisVector_front, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_back", _wrap_DualHistoAxisVector_back, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_assign", _wrap_DualHistoAxisVector_assign, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_resize", _wrap_DualHistoAxisVector_resize, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_insert", _wrap_DualHistoAxisVector_insert, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_reserve", _wrap_DualHistoAxisVector_reserve, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_capacity", _wrap_DualHistoAxisVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_DualHistoAxisVector", _wrap_delete_DualHistoAxisVector, METH_VARARGS, NULL},
	{ (char *)"DualHistoAxisVector_swigregister", DualHistoAxisVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntHistoND", _wrap_new_IntHistoND, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_dim", _wrap_IntHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_title", _wrap_IntHistoND_title, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_accumulatedDataLabel", _wrap_IntHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_binContents", _wrap_IntHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_overflows", _wrap_IntHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_axes", _wrap_IntHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_axis", _wrap_IntHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_nBins", _wrap_IntHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_nFillsTotal", _wrap_IntHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_nFillsInRange", _wrap_IntHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_nFillsOver", _wrap_IntHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_isUniformlyBinned", _wrap_IntHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_setTitle", _wrap_IntHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_setAccumulatedDataLabel", _wrap_IntHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_setAxisLabel", _wrap_IntHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_binVolume", _wrap_IntHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_binCenter", _wrap_IntHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_binBox", _wrap_IntHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_boundingBox", _wrap_IntHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_volume", _wrap_IntHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_integral", _wrap_IntHistoND_integral, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_clear", _wrap_IntHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_clearBinContents", _wrap_IntHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_clearOverflows", _wrap_IntHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"IntHistoND___eq__", _wrap_IntHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"IntHistoND___ne__", _wrap_IntHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_isSameData", _wrap_IntHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_recalculateNFillsFromData", _wrap_IntHistoND_recalculateNFillsFromData, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_setNFillsTotal", _wrap_IntHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_setNFillsOver", _wrap_IntHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_transpose", _wrap_IntHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_getModCount", _wrap_IntHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_incrModCount", _wrap_IntHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_classId", _wrap_IntHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_write", _wrap_IntHistoND_write, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_classname", _wrap_IntHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_version", _wrap_IntHistoND_version, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_read", _wrap_IntHistoND_read, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_examine", _wrap_IntHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_closestBin", _wrap_IntHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_setBin", _wrap_IntHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_setLinearBin", _wrap_IntHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_setBinsToConst", _wrap_IntHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_setOverflowsToConst", _wrap_IntHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_fill", _wrap_IntHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_IntHistoND", _wrap_delete_IntHistoND, METH_VARARGS, NULL},
	{ (char *)"IntHistoND_swigregister", IntHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongHistoND", _wrap_new_LLongHistoND, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_dim", _wrap_LLongHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_title", _wrap_LLongHistoND_title, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_accumulatedDataLabel", _wrap_LLongHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_binContents", _wrap_LLongHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_overflows", _wrap_LLongHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_axes", _wrap_LLongHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_axis", _wrap_LLongHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_nBins", _wrap_LLongHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_nFillsTotal", _wrap_LLongHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_nFillsInRange", _wrap_LLongHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_nFillsOver", _wrap_LLongHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_isUniformlyBinned", _wrap_LLongHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_setTitle", _wrap_LLongHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_setAccumulatedDataLabel", _wrap_LLongHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_setAxisLabel", _wrap_LLongHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_binVolume", _wrap_LLongHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_binCenter", _wrap_LLongHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_binBox", _wrap_LLongHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_boundingBox", _wrap_LLongHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_volume", _wrap_LLongHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_integral", _wrap_LLongHistoND_integral, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_clear", _wrap_LLongHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_clearBinContents", _wrap_LLongHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_clearOverflows", _wrap_LLongHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND___eq__", _wrap_LLongHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND___ne__", _wrap_LLongHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_isSameData", _wrap_LLongHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_recalculateNFillsFromData", _wrap_LLongHistoND_recalculateNFillsFromData, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_setNFillsTotal", _wrap_LLongHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_setNFillsOver", _wrap_LLongHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_transpose", _wrap_LLongHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_getModCount", _wrap_LLongHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_incrModCount", _wrap_LLongHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_classId", _wrap_LLongHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_write", _wrap_LLongHistoND_write, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_classname", _wrap_LLongHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_version", _wrap_LLongHistoND_version, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_read", _wrap_LLongHistoND_read, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_examine", _wrap_LLongHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_closestBin", _wrap_LLongHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_setBin", _wrap_LLongHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_setLinearBin", _wrap_LLongHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_setBinsToConst", _wrap_LLongHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_setOverflowsToConst", _wrap_LLongHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_fill", _wrap_LLongHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_LLongHistoND", _wrap_delete_LLongHistoND, METH_VARARGS, NULL},
	{ (char *)"LLongHistoND_swigregister", LLongHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharHistoND", _wrap_new_UCharHistoND, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_dim", _wrap_UCharHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_title", _wrap_UCharHistoND_title, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_accumulatedDataLabel", _wrap_UCharHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_binContents", _wrap_UCharHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_overflows", _wrap_UCharHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_axes", _wrap_UCharHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_axis", _wrap_UCharHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_nBins", _wrap_UCharHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_nFillsTotal", _wrap_UCharHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_nFillsInRange", _wrap_UCharHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_nFillsOver", _wrap_UCharHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_isUniformlyBinned", _wrap_UCharHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_setTitle", _wrap_UCharHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_setAccumulatedDataLabel", _wrap_UCharHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_setAxisLabel", _wrap_UCharHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_binVolume", _wrap_UCharHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_binCenter", _wrap_UCharHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_binBox", _wrap_UCharHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_boundingBox", _wrap_UCharHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_volume", _wrap_UCharHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_integral", _wrap_UCharHistoND_integral, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_clear", _wrap_UCharHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_clearBinContents", _wrap_UCharHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_clearOverflows", _wrap_UCharHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND___eq__", _wrap_UCharHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND___ne__", _wrap_UCharHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_isSameData", _wrap_UCharHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_recalculateNFillsFromData", _wrap_UCharHistoND_recalculateNFillsFromData, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_setNFillsTotal", _wrap_UCharHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_setNFillsOver", _wrap_UCharHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_transpose", _wrap_UCharHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_getModCount", _wrap_UCharHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_incrModCount", _wrap_UCharHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_classId", _wrap_UCharHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_write", _wrap_UCharHistoND_write, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_classname", _wrap_UCharHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_version", _wrap_UCharHistoND_version, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_read", _wrap_UCharHistoND_read, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_examine", _wrap_UCharHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_closestBin", _wrap_UCharHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_setBin", _wrap_UCharHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_setLinearBin", _wrap_UCharHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_setBinsToConst", _wrap_UCharHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_setOverflowsToConst", _wrap_UCharHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_fill", _wrap_UCharHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_UCharHistoND", _wrap_delete_UCharHistoND, METH_VARARGS, NULL},
	{ (char *)"UCharHistoND_swigregister", UCharHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatHistoND", _wrap_new_FloatHistoND, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_dim", _wrap_FloatHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_title", _wrap_FloatHistoND_title, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_accumulatedDataLabel", _wrap_FloatHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_binContents", _wrap_FloatHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_overflows", _wrap_FloatHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_axes", _wrap_FloatHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_axis", _wrap_FloatHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_nBins", _wrap_FloatHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_nFillsTotal", _wrap_FloatHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_nFillsInRange", _wrap_FloatHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_nFillsOver", _wrap_FloatHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_isUniformlyBinned", _wrap_FloatHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_setTitle", _wrap_FloatHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_setAccumulatedDataLabel", _wrap_FloatHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_setAxisLabel", _wrap_FloatHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_binVolume", _wrap_FloatHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_binCenter", _wrap_FloatHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_binBox", _wrap_FloatHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_boundingBox", _wrap_FloatHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_volume", _wrap_FloatHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_integral", _wrap_FloatHistoND_integral, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_clear", _wrap_FloatHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_clearBinContents", _wrap_FloatHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_clearOverflows", _wrap_FloatHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND___eq__", _wrap_FloatHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND___ne__", _wrap_FloatHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_isSameData", _wrap_FloatHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_recalculateNFillsFromData", _wrap_FloatHistoND_recalculateNFillsFromData, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_setNFillsTotal", _wrap_FloatHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_setNFillsOver", _wrap_FloatHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_transpose", _wrap_FloatHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_getModCount", _wrap_FloatHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_incrModCount", _wrap_FloatHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_classId", _wrap_FloatHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_write", _wrap_FloatHistoND_write, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_classname", _wrap_FloatHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_version", _wrap_FloatHistoND_version, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_read", _wrap_FloatHistoND_read, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_examine", _wrap_FloatHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_closestBin", _wrap_FloatHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_setBin", _wrap_FloatHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_setLinearBin", _wrap_FloatHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_setBinsToConst", _wrap_FloatHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_setOverflowsToConst", _wrap_FloatHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_fill", _wrap_FloatHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_fillC", _wrap_FloatHistoND_fillC, METH_VARARGS, NULL},
	{ (char *)"delete_FloatHistoND", _wrap_delete_FloatHistoND, METH_VARARGS, NULL},
	{ (char *)"FloatHistoND_swigregister", FloatHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleHistoND", _wrap_new_DoubleHistoND, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_dim", _wrap_DoubleHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_title", _wrap_DoubleHistoND_title, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_accumulatedDataLabel", _wrap_DoubleHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_binContents", _wrap_DoubleHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_overflows", _wrap_DoubleHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_axes", _wrap_DoubleHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_axis", _wrap_DoubleHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_nBins", _wrap_DoubleHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_nFillsTotal", _wrap_DoubleHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_nFillsInRange", _wrap_DoubleHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_nFillsOver", _wrap_DoubleHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_isUniformlyBinned", _wrap_DoubleHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_setTitle", _wrap_DoubleHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_setAccumulatedDataLabel", _wrap_DoubleHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_setAxisLabel", _wrap_DoubleHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_binVolume", _wrap_DoubleHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_binCenter", _wrap_DoubleHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_binBox", _wrap_DoubleHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_boundingBox", _wrap_DoubleHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_volume", _wrap_DoubleHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_integral", _wrap_DoubleHistoND_integral, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_clear", _wrap_DoubleHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_clearBinContents", _wrap_DoubleHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_clearOverflows", _wrap_DoubleHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND___eq__", _wrap_DoubleHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND___ne__", _wrap_DoubleHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_isSameData", _wrap_DoubleHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_recalculateNFillsFromData", _wrap_DoubleHistoND_recalculateNFillsFromData, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_setNFillsTotal", _wrap_DoubleHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_setNFillsOver", _wrap_DoubleHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_transpose", _wrap_DoubleHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_getModCount", _wrap_DoubleHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_incrModCount", _wrap_DoubleHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_classId", _wrap_DoubleHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_write", _wrap_DoubleHistoND_write, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_classname", _wrap_DoubleHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_version", _wrap_DoubleHistoND_version, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_read", _wrap_DoubleHistoND_read, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_examine", _wrap_DoubleHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_closestBin", _wrap_DoubleHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_setBin", _wrap_DoubleHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_setLinearBin", _wrap_DoubleHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_setBinsToConst", _wrap_DoubleHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_setOverflowsToConst", _wrap_DoubleHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_fill", _wrap_DoubleHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_fillC", _wrap_DoubleHistoND_fillC, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleHistoND", _wrap_delete_DoubleHistoND, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoND_swigregister", DoubleHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_StatAccHistoND", _wrap_new_StatAccHistoND, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_dim", _wrap_StatAccHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_title", _wrap_StatAccHistoND_title, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_accumulatedDataLabel", _wrap_StatAccHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_binContents", _wrap_StatAccHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_overflows", _wrap_StatAccHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_axes", _wrap_StatAccHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_axis", _wrap_StatAccHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_nBins", _wrap_StatAccHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_nFillsTotal", _wrap_StatAccHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_nFillsInRange", _wrap_StatAccHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_nFillsOver", _wrap_StatAccHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_isUniformlyBinned", _wrap_StatAccHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_setTitle", _wrap_StatAccHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_setAccumulatedDataLabel", _wrap_StatAccHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_setAxisLabel", _wrap_StatAccHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_binVolume", _wrap_StatAccHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_binCenter", _wrap_StatAccHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_binBox", _wrap_StatAccHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_boundingBox", _wrap_StatAccHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_volume", _wrap_StatAccHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_clear", _wrap_StatAccHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_clearBinContents", _wrap_StatAccHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_clearOverflows", _wrap_StatAccHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND___eq__", _wrap_StatAccHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND___ne__", _wrap_StatAccHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_isSameData", _wrap_StatAccHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_setNFillsTotal", _wrap_StatAccHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_setNFillsOver", _wrap_StatAccHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_transpose", _wrap_StatAccHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_getModCount", _wrap_StatAccHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_incrModCount", _wrap_StatAccHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_classId", _wrap_StatAccHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_write", _wrap_StatAccHistoND_write, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_classname", _wrap_StatAccHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_version", _wrap_StatAccHistoND_version, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_read", _wrap_StatAccHistoND_read, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_examine", _wrap_StatAccHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_closestBin", _wrap_StatAccHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_setBin", _wrap_StatAccHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_setLinearBin", _wrap_StatAccHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_setBinsToConst", _wrap_StatAccHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_setOverflowsToConst", _wrap_StatAccHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_fill", _wrap_StatAccHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_fillC", _wrap_StatAccHistoND_fillC, METH_VARARGS, NULL},
	{ (char *)"delete_StatAccHistoND", _wrap_delete_StatAccHistoND, METH_VARARGS, NULL},
	{ (char *)"StatAccHistoND_swigregister", StatAccHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_WStatAccHistoND", _wrap_new_WStatAccHistoND, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_dim", _wrap_WStatAccHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_title", _wrap_WStatAccHistoND_title, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_accumulatedDataLabel", _wrap_WStatAccHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_binContents", _wrap_WStatAccHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_overflows", _wrap_WStatAccHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_axes", _wrap_WStatAccHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_axis", _wrap_WStatAccHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_nBins", _wrap_WStatAccHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_nFillsTotal", _wrap_WStatAccHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_nFillsInRange", _wrap_WStatAccHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_nFillsOver", _wrap_WStatAccHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_isUniformlyBinned", _wrap_WStatAccHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_setTitle", _wrap_WStatAccHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_setAccumulatedDataLabel", _wrap_WStatAccHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_setAxisLabel", _wrap_WStatAccHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_binVolume", _wrap_WStatAccHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_binCenter", _wrap_WStatAccHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_binBox", _wrap_WStatAccHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_boundingBox", _wrap_WStatAccHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_volume", _wrap_WStatAccHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_clear", _wrap_WStatAccHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_clearBinContents", _wrap_WStatAccHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_clearOverflows", _wrap_WStatAccHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND___eq__", _wrap_WStatAccHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND___ne__", _wrap_WStatAccHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_isSameData", _wrap_WStatAccHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_setNFillsTotal", _wrap_WStatAccHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_setNFillsOver", _wrap_WStatAccHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_transpose", _wrap_WStatAccHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_getModCount", _wrap_WStatAccHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_incrModCount", _wrap_WStatAccHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_classId", _wrap_WStatAccHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_write", _wrap_WStatAccHistoND_write, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_classname", _wrap_WStatAccHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_version", _wrap_WStatAccHistoND_version, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_read", _wrap_WStatAccHistoND_read, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_examine", _wrap_WStatAccHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_closestBin", _wrap_WStatAccHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_setBin", _wrap_WStatAccHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_setLinearBin", _wrap_WStatAccHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_setBinsToConst", _wrap_WStatAccHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_setOverflowsToConst", _wrap_WStatAccHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_fill", _wrap_WStatAccHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_WStatAccHistoND", _wrap_delete_WStatAccHistoND, METH_VARARGS, NULL},
	{ (char *)"WStatAccHistoND_swigregister", WStatAccHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_BinSummaryHistoND", _wrap_new_BinSummaryHistoND, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_dim", _wrap_BinSummaryHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_title", _wrap_BinSummaryHistoND_title, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_accumulatedDataLabel", _wrap_BinSummaryHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_binContents", _wrap_BinSummaryHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_overflows", _wrap_BinSummaryHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_axes", _wrap_BinSummaryHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_axis", _wrap_BinSummaryHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_nBins", _wrap_BinSummaryHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_nFillsTotal", _wrap_BinSummaryHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_nFillsInRange", _wrap_BinSummaryHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_nFillsOver", _wrap_BinSummaryHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_isUniformlyBinned", _wrap_BinSummaryHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_setTitle", _wrap_BinSummaryHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_setAccumulatedDataLabel", _wrap_BinSummaryHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_setAxisLabel", _wrap_BinSummaryHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_binVolume", _wrap_BinSummaryHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_binCenter", _wrap_BinSummaryHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_binBox", _wrap_BinSummaryHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_boundingBox", _wrap_BinSummaryHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_volume", _wrap_BinSummaryHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_clear", _wrap_BinSummaryHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_clearBinContents", _wrap_BinSummaryHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_clearOverflows", _wrap_BinSummaryHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND___eq__", _wrap_BinSummaryHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND___ne__", _wrap_BinSummaryHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_isSameData", _wrap_BinSummaryHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_setNFillsTotal", _wrap_BinSummaryHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_setNFillsOver", _wrap_BinSummaryHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_transpose", _wrap_BinSummaryHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_getModCount", _wrap_BinSummaryHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_incrModCount", _wrap_BinSummaryHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_classId", _wrap_BinSummaryHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_write", _wrap_BinSummaryHistoND_write, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_classname", _wrap_BinSummaryHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_version", _wrap_BinSummaryHistoND_version, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_read", _wrap_BinSummaryHistoND_read, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_examine", _wrap_BinSummaryHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_closestBin", _wrap_BinSummaryHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_setBin", _wrap_BinSummaryHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_setLinearBin", _wrap_BinSummaryHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_setBinsToConst", _wrap_BinSummaryHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_setOverflowsToConst", _wrap_BinSummaryHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_fill", _wrap_BinSummaryHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_BinSummaryHistoND", _wrap_delete_BinSummaryHistoND, METH_VARARGS, NULL},
	{ (char *)"BinSummaryHistoND_swigregister", BinSummaryHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FSampleAccHistoND", _wrap_new_FSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_dim", _wrap_FSampleAccHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_title", _wrap_FSampleAccHistoND_title, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_accumulatedDataLabel", _wrap_FSampleAccHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_binContents", _wrap_FSampleAccHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_overflows", _wrap_FSampleAccHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_axes", _wrap_FSampleAccHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_axis", _wrap_FSampleAccHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_nBins", _wrap_FSampleAccHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_nFillsTotal", _wrap_FSampleAccHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_nFillsInRange", _wrap_FSampleAccHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_nFillsOver", _wrap_FSampleAccHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_isUniformlyBinned", _wrap_FSampleAccHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_setTitle", _wrap_FSampleAccHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_setAccumulatedDataLabel", _wrap_FSampleAccHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_setAxisLabel", _wrap_FSampleAccHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_binVolume", _wrap_FSampleAccHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_binCenter", _wrap_FSampleAccHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_binBox", _wrap_FSampleAccHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_boundingBox", _wrap_FSampleAccHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_volume", _wrap_FSampleAccHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_clear", _wrap_FSampleAccHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_clearBinContents", _wrap_FSampleAccHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_clearOverflows", _wrap_FSampleAccHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND___eq__", _wrap_FSampleAccHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND___ne__", _wrap_FSampleAccHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_isSameData", _wrap_FSampleAccHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_setNFillsTotal", _wrap_FSampleAccHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_setNFillsOver", _wrap_FSampleAccHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_transpose", _wrap_FSampleAccHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_getModCount", _wrap_FSampleAccHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_incrModCount", _wrap_FSampleAccHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_classId", _wrap_FSampleAccHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_write", _wrap_FSampleAccHistoND_write, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_classname", _wrap_FSampleAccHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_version", _wrap_FSampleAccHistoND_version, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_read", _wrap_FSampleAccHistoND_read, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_examine", _wrap_FSampleAccHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_closestBin", _wrap_FSampleAccHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_setBin", _wrap_FSampleAccHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_setLinearBin", _wrap_FSampleAccHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_setBinsToConst", _wrap_FSampleAccHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_setOverflowsToConst", _wrap_FSampleAccHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_fill", _wrap_FSampleAccHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_fillC", _wrap_FSampleAccHistoND_fillC, METH_VARARGS, NULL},
	{ (char *)"delete_FSampleAccHistoND", _wrap_delete_FSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"FSampleAccHistoND_swigregister", FSampleAccHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DSampleAccHistoND", _wrap_new_DSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_dim", _wrap_DSampleAccHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_title", _wrap_DSampleAccHistoND_title, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_accumulatedDataLabel", _wrap_DSampleAccHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_binContents", _wrap_DSampleAccHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_overflows", _wrap_DSampleAccHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_axes", _wrap_DSampleAccHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_axis", _wrap_DSampleAccHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_nBins", _wrap_DSampleAccHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_nFillsTotal", _wrap_DSampleAccHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_nFillsInRange", _wrap_DSampleAccHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_nFillsOver", _wrap_DSampleAccHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_isUniformlyBinned", _wrap_DSampleAccHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_setTitle", _wrap_DSampleAccHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_setAccumulatedDataLabel", _wrap_DSampleAccHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_setAxisLabel", _wrap_DSampleAccHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_binVolume", _wrap_DSampleAccHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_binCenter", _wrap_DSampleAccHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_binBox", _wrap_DSampleAccHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_boundingBox", _wrap_DSampleAccHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_volume", _wrap_DSampleAccHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_clear", _wrap_DSampleAccHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_clearBinContents", _wrap_DSampleAccHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_clearOverflows", _wrap_DSampleAccHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND___eq__", _wrap_DSampleAccHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND___ne__", _wrap_DSampleAccHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_isSameData", _wrap_DSampleAccHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_setNFillsTotal", _wrap_DSampleAccHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_setNFillsOver", _wrap_DSampleAccHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_transpose", _wrap_DSampleAccHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_getModCount", _wrap_DSampleAccHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_incrModCount", _wrap_DSampleAccHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_classId", _wrap_DSampleAccHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_write", _wrap_DSampleAccHistoND_write, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_classname", _wrap_DSampleAccHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_version", _wrap_DSampleAccHistoND_version, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_read", _wrap_DSampleAccHistoND_read, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_examine", _wrap_DSampleAccHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_closestBin", _wrap_DSampleAccHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_setBin", _wrap_DSampleAccHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_setLinearBin", _wrap_DSampleAccHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_setBinsToConst", _wrap_DSampleAccHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_setOverflowsToConst", _wrap_DSampleAccHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_fill", _wrap_DSampleAccHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_fillC", _wrap_DSampleAccHistoND_fillC, METH_VARARGS, NULL},
	{ (char *)"delete_DSampleAccHistoND", _wrap_delete_DSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"DSampleAccHistoND_swigregister", DSampleAccHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DWSampleAccHistoND", _wrap_new_DWSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_dim", _wrap_DWSampleAccHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_title", _wrap_DWSampleAccHistoND_title, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_accumulatedDataLabel", _wrap_DWSampleAccHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_binContents", _wrap_DWSampleAccHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_overflows", _wrap_DWSampleAccHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_axes", _wrap_DWSampleAccHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_axis", _wrap_DWSampleAccHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_nBins", _wrap_DWSampleAccHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_nFillsTotal", _wrap_DWSampleAccHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_nFillsInRange", _wrap_DWSampleAccHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_nFillsOver", _wrap_DWSampleAccHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_isUniformlyBinned", _wrap_DWSampleAccHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_setTitle", _wrap_DWSampleAccHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_setAccumulatedDataLabel", _wrap_DWSampleAccHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_setAxisLabel", _wrap_DWSampleAccHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_binVolume", _wrap_DWSampleAccHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_binCenter", _wrap_DWSampleAccHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_binBox", _wrap_DWSampleAccHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_boundingBox", _wrap_DWSampleAccHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_volume", _wrap_DWSampleAccHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_clear", _wrap_DWSampleAccHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_clearBinContents", _wrap_DWSampleAccHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_clearOverflows", _wrap_DWSampleAccHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND___eq__", _wrap_DWSampleAccHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND___ne__", _wrap_DWSampleAccHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_isSameData", _wrap_DWSampleAccHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_setNFillsTotal", _wrap_DWSampleAccHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_setNFillsOver", _wrap_DWSampleAccHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_transpose", _wrap_DWSampleAccHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_getModCount", _wrap_DWSampleAccHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_incrModCount", _wrap_DWSampleAccHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_classId", _wrap_DWSampleAccHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_write", _wrap_DWSampleAccHistoND_write, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_classname", _wrap_DWSampleAccHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_version", _wrap_DWSampleAccHistoND_version, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_read", _wrap_DWSampleAccHistoND_read, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_examine", _wrap_DWSampleAccHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_closestBin", _wrap_DWSampleAccHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_setBin", _wrap_DWSampleAccHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_setLinearBin", _wrap_DWSampleAccHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_setBinsToConst", _wrap_DWSampleAccHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_setOverflowsToConst", _wrap_DWSampleAccHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_fill", _wrap_DWSampleAccHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_DWSampleAccHistoND", _wrap_delete_DWSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccHistoND_swigregister", DWSampleAccHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntNUHistoND", _wrap_new_IntNUHistoND, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_dim", _wrap_IntNUHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_title", _wrap_IntNUHistoND_title, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_accumulatedDataLabel", _wrap_IntNUHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_binContents", _wrap_IntNUHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_overflows", _wrap_IntNUHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_axes", _wrap_IntNUHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_axis", _wrap_IntNUHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_nBins", _wrap_IntNUHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_nFillsTotal", _wrap_IntNUHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_nFillsInRange", _wrap_IntNUHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_nFillsOver", _wrap_IntNUHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_isUniformlyBinned", _wrap_IntNUHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_setTitle", _wrap_IntNUHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_setAccumulatedDataLabel", _wrap_IntNUHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_setAxisLabel", _wrap_IntNUHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_binVolume", _wrap_IntNUHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_binCenter", _wrap_IntNUHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_binBox", _wrap_IntNUHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_boundingBox", _wrap_IntNUHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_volume", _wrap_IntNUHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_integral", _wrap_IntNUHistoND_integral, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_clear", _wrap_IntNUHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_clearBinContents", _wrap_IntNUHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_clearOverflows", _wrap_IntNUHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND___eq__", _wrap_IntNUHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND___ne__", _wrap_IntNUHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_isSameData", _wrap_IntNUHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_recalculateNFillsFromData", _wrap_IntNUHistoND_recalculateNFillsFromData, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_setNFillsTotal", _wrap_IntNUHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_setNFillsOver", _wrap_IntNUHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_transpose", _wrap_IntNUHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_getModCount", _wrap_IntNUHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_incrModCount", _wrap_IntNUHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_classId", _wrap_IntNUHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_write", _wrap_IntNUHistoND_write, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_classname", _wrap_IntNUHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_version", _wrap_IntNUHistoND_version, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_read", _wrap_IntNUHistoND_read, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_examine", _wrap_IntNUHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_closestBin", _wrap_IntNUHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_setBin", _wrap_IntNUHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_setLinearBin", _wrap_IntNUHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_setBinsToConst", _wrap_IntNUHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_setOverflowsToConst", _wrap_IntNUHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_fill", _wrap_IntNUHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_IntNUHistoND", _wrap_delete_IntNUHistoND, METH_VARARGS, NULL},
	{ (char *)"IntNUHistoND_swigregister", IntNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongNUHistoND", _wrap_new_LLongNUHistoND, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_dim", _wrap_LLongNUHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_title", _wrap_LLongNUHistoND_title, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_accumulatedDataLabel", _wrap_LLongNUHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_binContents", _wrap_LLongNUHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_overflows", _wrap_LLongNUHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_axes", _wrap_LLongNUHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_axis", _wrap_LLongNUHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_nBins", _wrap_LLongNUHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_nFillsTotal", _wrap_LLongNUHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_nFillsInRange", _wrap_LLongNUHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_nFillsOver", _wrap_LLongNUHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_isUniformlyBinned", _wrap_LLongNUHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_setTitle", _wrap_LLongNUHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_setAccumulatedDataLabel", _wrap_LLongNUHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_setAxisLabel", _wrap_LLongNUHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_binVolume", _wrap_LLongNUHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_binCenter", _wrap_LLongNUHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_binBox", _wrap_LLongNUHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_boundingBox", _wrap_LLongNUHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_volume", _wrap_LLongNUHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_integral", _wrap_LLongNUHistoND_integral, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_clear", _wrap_LLongNUHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_clearBinContents", _wrap_LLongNUHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_clearOverflows", _wrap_LLongNUHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND___eq__", _wrap_LLongNUHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND___ne__", _wrap_LLongNUHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_isSameData", _wrap_LLongNUHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_recalculateNFillsFromData", _wrap_LLongNUHistoND_recalculateNFillsFromData, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_setNFillsTotal", _wrap_LLongNUHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_setNFillsOver", _wrap_LLongNUHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_transpose", _wrap_LLongNUHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_getModCount", _wrap_LLongNUHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_incrModCount", _wrap_LLongNUHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_classId", _wrap_LLongNUHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_write", _wrap_LLongNUHistoND_write, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_classname", _wrap_LLongNUHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_version", _wrap_LLongNUHistoND_version, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_read", _wrap_LLongNUHistoND_read, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_examine", _wrap_LLongNUHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_closestBin", _wrap_LLongNUHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_setBin", _wrap_LLongNUHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_setLinearBin", _wrap_LLongNUHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_setBinsToConst", _wrap_LLongNUHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_setOverflowsToConst", _wrap_LLongNUHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_fill", _wrap_LLongNUHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_LLongNUHistoND", _wrap_delete_LLongNUHistoND, METH_VARARGS, NULL},
	{ (char *)"LLongNUHistoND_swigregister", LLongNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharNUHistoND", _wrap_new_UCharNUHistoND, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_dim", _wrap_UCharNUHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_title", _wrap_UCharNUHistoND_title, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_accumulatedDataLabel", _wrap_UCharNUHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_binContents", _wrap_UCharNUHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_overflows", _wrap_UCharNUHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_axes", _wrap_UCharNUHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_axis", _wrap_UCharNUHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_nBins", _wrap_UCharNUHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_nFillsTotal", _wrap_UCharNUHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_nFillsInRange", _wrap_UCharNUHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_nFillsOver", _wrap_UCharNUHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_isUniformlyBinned", _wrap_UCharNUHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_setTitle", _wrap_UCharNUHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_setAccumulatedDataLabel", _wrap_UCharNUHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_setAxisLabel", _wrap_UCharNUHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_binVolume", _wrap_UCharNUHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_binCenter", _wrap_UCharNUHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_binBox", _wrap_UCharNUHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_boundingBox", _wrap_UCharNUHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_volume", _wrap_UCharNUHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_integral", _wrap_UCharNUHistoND_integral, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_clear", _wrap_UCharNUHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_clearBinContents", _wrap_UCharNUHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_clearOverflows", _wrap_UCharNUHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND___eq__", _wrap_UCharNUHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND___ne__", _wrap_UCharNUHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_isSameData", _wrap_UCharNUHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_recalculateNFillsFromData", _wrap_UCharNUHistoND_recalculateNFillsFromData, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_setNFillsTotal", _wrap_UCharNUHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_setNFillsOver", _wrap_UCharNUHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_transpose", _wrap_UCharNUHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_getModCount", _wrap_UCharNUHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_incrModCount", _wrap_UCharNUHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_classId", _wrap_UCharNUHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_write", _wrap_UCharNUHistoND_write, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_classname", _wrap_UCharNUHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_version", _wrap_UCharNUHistoND_version, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_read", _wrap_UCharNUHistoND_read, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_examine", _wrap_UCharNUHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_closestBin", _wrap_UCharNUHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_setBin", _wrap_UCharNUHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_setLinearBin", _wrap_UCharNUHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_setBinsToConst", _wrap_UCharNUHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_setOverflowsToConst", _wrap_UCharNUHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_fill", _wrap_UCharNUHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_UCharNUHistoND", _wrap_delete_UCharNUHistoND, METH_VARARGS, NULL},
	{ (char *)"UCharNUHistoND_swigregister", UCharNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatNUHistoND", _wrap_new_FloatNUHistoND, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_dim", _wrap_FloatNUHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_title", _wrap_FloatNUHistoND_title, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_accumulatedDataLabel", _wrap_FloatNUHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_binContents", _wrap_FloatNUHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_overflows", _wrap_FloatNUHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_axes", _wrap_FloatNUHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_axis", _wrap_FloatNUHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_nBins", _wrap_FloatNUHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_nFillsTotal", _wrap_FloatNUHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_nFillsInRange", _wrap_FloatNUHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_nFillsOver", _wrap_FloatNUHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_isUniformlyBinned", _wrap_FloatNUHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_setTitle", _wrap_FloatNUHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_setAccumulatedDataLabel", _wrap_FloatNUHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_setAxisLabel", _wrap_FloatNUHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_binVolume", _wrap_FloatNUHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_binCenter", _wrap_FloatNUHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_binBox", _wrap_FloatNUHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_boundingBox", _wrap_FloatNUHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_volume", _wrap_FloatNUHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_integral", _wrap_FloatNUHistoND_integral, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_clear", _wrap_FloatNUHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_clearBinContents", _wrap_FloatNUHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_clearOverflows", _wrap_FloatNUHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND___eq__", _wrap_FloatNUHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND___ne__", _wrap_FloatNUHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_isSameData", _wrap_FloatNUHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_recalculateNFillsFromData", _wrap_FloatNUHistoND_recalculateNFillsFromData, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_setNFillsTotal", _wrap_FloatNUHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_setNFillsOver", _wrap_FloatNUHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_transpose", _wrap_FloatNUHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_getModCount", _wrap_FloatNUHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_incrModCount", _wrap_FloatNUHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_classId", _wrap_FloatNUHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_write", _wrap_FloatNUHistoND_write, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_classname", _wrap_FloatNUHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_version", _wrap_FloatNUHistoND_version, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_read", _wrap_FloatNUHistoND_read, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_examine", _wrap_FloatNUHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_closestBin", _wrap_FloatNUHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_setBin", _wrap_FloatNUHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_setLinearBin", _wrap_FloatNUHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_setBinsToConst", _wrap_FloatNUHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_setOverflowsToConst", _wrap_FloatNUHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_fill", _wrap_FloatNUHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_FloatNUHistoND", _wrap_delete_FloatNUHistoND, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoND_swigregister", FloatNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleNUHistoND", _wrap_new_DoubleNUHistoND, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_dim", _wrap_DoubleNUHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_title", _wrap_DoubleNUHistoND_title, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_accumulatedDataLabel", _wrap_DoubleNUHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_binContents", _wrap_DoubleNUHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_overflows", _wrap_DoubleNUHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_axes", _wrap_DoubleNUHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_axis", _wrap_DoubleNUHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_nBins", _wrap_DoubleNUHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_nFillsTotal", _wrap_DoubleNUHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_nFillsInRange", _wrap_DoubleNUHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_nFillsOver", _wrap_DoubleNUHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_isUniformlyBinned", _wrap_DoubleNUHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_setTitle", _wrap_DoubleNUHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_setAccumulatedDataLabel", _wrap_DoubleNUHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_setAxisLabel", _wrap_DoubleNUHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_binVolume", _wrap_DoubleNUHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_binCenter", _wrap_DoubleNUHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_binBox", _wrap_DoubleNUHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_boundingBox", _wrap_DoubleNUHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_volume", _wrap_DoubleNUHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_integral", _wrap_DoubleNUHistoND_integral, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_clear", _wrap_DoubleNUHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_clearBinContents", _wrap_DoubleNUHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_clearOverflows", _wrap_DoubleNUHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND___eq__", _wrap_DoubleNUHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND___ne__", _wrap_DoubleNUHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_isSameData", _wrap_DoubleNUHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_recalculateNFillsFromData", _wrap_DoubleNUHistoND_recalculateNFillsFromData, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_setNFillsTotal", _wrap_DoubleNUHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_setNFillsOver", _wrap_DoubleNUHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_transpose", _wrap_DoubleNUHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_getModCount", _wrap_DoubleNUHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_incrModCount", _wrap_DoubleNUHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_classId", _wrap_DoubleNUHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_write", _wrap_DoubleNUHistoND_write, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_classname", _wrap_DoubleNUHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_version", _wrap_DoubleNUHistoND_version, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_read", _wrap_DoubleNUHistoND_read, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_examine", _wrap_DoubleNUHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_closestBin", _wrap_DoubleNUHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_setBin", _wrap_DoubleNUHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_setLinearBin", _wrap_DoubleNUHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_setBinsToConst", _wrap_DoubleNUHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_setOverflowsToConst", _wrap_DoubleNUHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_fill", _wrap_DoubleNUHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleNUHistoND", _wrap_delete_DoubleNUHistoND, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoND_swigregister", DoubleNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_StatAccNUHistoND", _wrap_new_StatAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_dim", _wrap_StatAccNUHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_title", _wrap_StatAccNUHistoND_title, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_accumulatedDataLabel", _wrap_StatAccNUHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_binContents", _wrap_StatAccNUHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_overflows", _wrap_StatAccNUHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_axes", _wrap_StatAccNUHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_axis", _wrap_StatAccNUHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_nBins", _wrap_StatAccNUHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_nFillsTotal", _wrap_StatAccNUHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_nFillsInRange", _wrap_StatAccNUHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_nFillsOver", _wrap_StatAccNUHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_isUniformlyBinned", _wrap_StatAccNUHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_setTitle", _wrap_StatAccNUHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_setAccumulatedDataLabel", _wrap_StatAccNUHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_setAxisLabel", _wrap_StatAccNUHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_binVolume", _wrap_StatAccNUHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_binCenter", _wrap_StatAccNUHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_binBox", _wrap_StatAccNUHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_boundingBox", _wrap_StatAccNUHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_volume", _wrap_StatAccNUHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_clear", _wrap_StatAccNUHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_clearBinContents", _wrap_StatAccNUHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_clearOverflows", _wrap_StatAccNUHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND___eq__", _wrap_StatAccNUHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND___ne__", _wrap_StatAccNUHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_isSameData", _wrap_StatAccNUHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_setNFillsTotal", _wrap_StatAccNUHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_setNFillsOver", _wrap_StatAccNUHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_transpose", _wrap_StatAccNUHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_getModCount", _wrap_StatAccNUHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_incrModCount", _wrap_StatAccNUHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_classId", _wrap_StatAccNUHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_write", _wrap_StatAccNUHistoND_write, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_classname", _wrap_StatAccNUHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_version", _wrap_StatAccNUHistoND_version, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_read", _wrap_StatAccNUHistoND_read, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_examine", _wrap_StatAccNUHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_closestBin", _wrap_StatAccNUHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_setBin", _wrap_StatAccNUHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_setLinearBin", _wrap_StatAccNUHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_setBinsToConst", _wrap_StatAccNUHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_setOverflowsToConst", _wrap_StatAccNUHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_fill", _wrap_StatAccNUHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_StatAccNUHistoND", _wrap_delete_StatAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"StatAccNUHistoND_swigregister", StatAccNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_WStatAccNUHistoND", _wrap_new_WStatAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_dim", _wrap_WStatAccNUHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_title", _wrap_WStatAccNUHistoND_title, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_accumulatedDataLabel", _wrap_WStatAccNUHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_binContents", _wrap_WStatAccNUHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_overflows", _wrap_WStatAccNUHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_axes", _wrap_WStatAccNUHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_axis", _wrap_WStatAccNUHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_nBins", _wrap_WStatAccNUHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_nFillsTotal", _wrap_WStatAccNUHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_nFillsInRange", _wrap_WStatAccNUHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_nFillsOver", _wrap_WStatAccNUHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_isUniformlyBinned", _wrap_WStatAccNUHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_setTitle", _wrap_WStatAccNUHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_setAccumulatedDataLabel", _wrap_WStatAccNUHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_setAxisLabel", _wrap_WStatAccNUHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_binVolume", _wrap_WStatAccNUHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_binCenter", _wrap_WStatAccNUHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_binBox", _wrap_WStatAccNUHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_boundingBox", _wrap_WStatAccNUHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_volume", _wrap_WStatAccNUHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_clear", _wrap_WStatAccNUHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_clearBinContents", _wrap_WStatAccNUHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_clearOverflows", _wrap_WStatAccNUHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND___eq__", _wrap_WStatAccNUHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND___ne__", _wrap_WStatAccNUHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_isSameData", _wrap_WStatAccNUHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_setNFillsTotal", _wrap_WStatAccNUHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_setNFillsOver", _wrap_WStatAccNUHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_transpose", _wrap_WStatAccNUHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_getModCount", _wrap_WStatAccNUHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_incrModCount", _wrap_WStatAccNUHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_classId", _wrap_WStatAccNUHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_write", _wrap_WStatAccNUHistoND_write, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_classname", _wrap_WStatAccNUHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_version", _wrap_WStatAccNUHistoND_version, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_read", _wrap_WStatAccNUHistoND_read, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_examine", _wrap_WStatAccNUHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_closestBin", _wrap_WStatAccNUHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_setBin", _wrap_WStatAccNUHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_setLinearBin", _wrap_WStatAccNUHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_setBinsToConst", _wrap_WStatAccNUHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_setOverflowsToConst", _wrap_WStatAccNUHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_fill", _wrap_WStatAccNUHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_WStatAccNUHistoND", _wrap_delete_WStatAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"WStatAccNUHistoND_swigregister", WStatAccNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_BinSummaryNUHistoND", _wrap_new_BinSummaryNUHistoND, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_dim", _wrap_BinSummaryNUHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_title", _wrap_BinSummaryNUHistoND_title, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_accumulatedDataLabel", _wrap_BinSummaryNUHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_binContents", _wrap_BinSummaryNUHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_overflows", _wrap_BinSummaryNUHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_axes", _wrap_BinSummaryNUHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_axis", _wrap_BinSummaryNUHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_nBins", _wrap_BinSummaryNUHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_nFillsTotal", _wrap_BinSummaryNUHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_nFillsInRange", _wrap_BinSummaryNUHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_nFillsOver", _wrap_BinSummaryNUHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_isUniformlyBinned", _wrap_BinSummaryNUHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_setTitle", _wrap_BinSummaryNUHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_setAccumulatedDataLabel", _wrap_BinSummaryNUHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_setAxisLabel", _wrap_BinSummaryNUHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_binVolume", _wrap_BinSummaryNUHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_binCenter", _wrap_BinSummaryNUHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_binBox", _wrap_BinSummaryNUHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_boundingBox", _wrap_BinSummaryNUHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_volume", _wrap_BinSummaryNUHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_clear", _wrap_BinSummaryNUHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_clearBinContents", _wrap_BinSummaryNUHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_clearOverflows", _wrap_BinSummaryNUHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND___eq__", _wrap_BinSummaryNUHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND___ne__", _wrap_BinSummaryNUHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_isSameData", _wrap_BinSummaryNUHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_setNFillsTotal", _wrap_BinSummaryNUHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_setNFillsOver", _wrap_BinSummaryNUHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_transpose", _wrap_BinSummaryNUHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_getModCount", _wrap_BinSummaryNUHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_incrModCount", _wrap_BinSummaryNUHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_classId", _wrap_BinSummaryNUHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_write", _wrap_BinSummaryNUHistoND_write, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_classname", _wrap_BinSummaryNUHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_version", _wrap_BinSummaryNUHistoND_version, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_read", _wrap_BinSummaryNUHistoND_read, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_examine", _wrap_BinSummaryNUHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_closestBin", _wrap_BinSummaryNUHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_setBin", _wrap_BinSummaryNUHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_setLinearBin", _wrap_BinSummaryNUHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_setBinsToConst", _wrap_BinSummaryNUHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_setOverflowsToConst", _wrap_BinSummaryNUHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_fill", _wrap_BinSummaryNUHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_BinSummaryNUHistoND", _wrap_delete_BinSummaryNUHistoND, METH_VARARGS, NULL},
	{ (char *)"BinSummaryNUHistoND_swigregister", BinSummaryNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FSampleAccNUHistoND", _wrap_new_FSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_dim", _wrap_FSampleAccNUHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_title", _wrap_FSampleAccNUHistoND_title, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_accumulatedDataLabel", _wrap_FSampleAccNUHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_binContents", _wrap_FSampleAccNUHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_overflows", _wrap_FSampleAccNUHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_axes", _wrap_FSampleAccNUHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_axis", _wrap_FSampleAccNUHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_nBins", _wrap_FSampleAccNUHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_nFillsTotal", _wrap_FSampleAccNUHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_nFillsInRange", _wrap_FSampleAccNUHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_nFillsOver", _wrap_FSampleAccNUHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_isUniformlyBinned", _wrap_FSampleAccNUHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_setTitle", _wrap_FSampleAccNUHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_setAccumulatedDataLabel", _wrap_FSampleAccNUHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_setAxisLabel", _wrap_FSampleAccNUHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_binVolume", _wrap_FSampleAccNUHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_binCenter", _wrap_FSampleAccNUHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_binBox", _wrap_FSampleAccNUHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_boundingBox", _wrap_FSampleAccNUHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_volume", _wrap_FSampleAccNUHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_clear", _wrap_FSampleAccNUHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_clearBinContents", _wrap_FSampleAccNUHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_clearOverflows", _wrap_FSampleAccNUHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND___eq__", _wrap_FSampleAccNUHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND___ne__", _wrap_FSampleAccNUHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_isSameData", _wrap_FSampleAccNUHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_setNFillsTotal", _wrap_FSampleAccNUHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_setNFillsOver", _wrap_FSampleAccNUHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_transpose", _wrap_FSampleAccNUHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_getModCount", _wrap_FSampleAccNUHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_incrModCount", _wrap_FSampleAccNUHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_classId", _wrap_FSampleAccNUHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_write", _wrap_FSampleAccNUHistoND_write, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_classname", _wrap_FSampleAccNUHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_version", _wrap_FSampleAccNUHistoND_version, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_read", _wrap_FSampleAccNUHistoND_read, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_examine", _wrap_FSampleAccNUHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_closestBin", _wrap_FSampleAccNUHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_setBin", _wrap_FSampleAccNUHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_setLinearBin", _wrap_FSampleAccNUHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_setBinsToConst", _wrap_FSampleAccNUHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_setOverflowsToConst", _wrap_FSampleAccNUHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_fill", _wrap_FSampleAccNUHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_FSampleAccNUHistoND", _wrap_delete_FSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"FSampleAccNUHistoND_swigregister", FSampleAccNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DSampleAccNUHistoND", _wrap_new_DSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_dim", _wrap_DSampleAccNUHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_title", _wrap_DSampleAccNUHistoND_title, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_accumulatedDataLabel", _wrap_DSampleAccNUHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_binContents", _wrap_DSampleAccNUHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_overflows", _wrap_DSampleAccNUHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_axes", _wrap_DSampleAccNUHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_axis", _wrap_DSampleAccNUHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_nBins", _wrap_DSampleAccNUHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_nFillsTotal", _wrap_DSampleAccNUHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_nFillsInRange", _wrap_DSampleAccNUHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_nFillsOver", _wrap_DSampleAccNUHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_isUniformlyBinned", _wrap_DSampleAccNUHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_setTitle", _wrap_DSampleAccNUHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_setAccumulatedDataLabel", _wrap_DSampleAccNUHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_setAxisLabel", _wrap_DSampleAccNUHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_binVolume", _wrap_DSampleAccNUHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_binCenter", _wrap_DSampleAccNUHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_binBox", _wrap_DSampleAccNUHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_boundingBox", _wrap_DSampleAccNUHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_volume", _wrap_DSampleAccNUHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_clear", _wrap_DSampleAccNUHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_clearBinContents", _wrap_DSampleAccNUHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_clearOverflows", _wrap_DSampleAccNUHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND___eq__", _wrap_DSampleAccNUHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND___ne__", _wrap_DSampleAccNUHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_isSameData", _wrap_DSampleAccNUHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_setNFillsTotal", _wrap_DSampleAccNUHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_setNFillsOver", _wrap_DSampleAccNUHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_transpose", _wrap_DSampleAccNUHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_getModCount", _wrap_DSampleAccNUHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_incrModCount", _wrap_DSampleAccNUHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_classId", _wrap_DSampleAccNUHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_write", _wrap_DSampleAccNUHistoND_write, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_classname", _wrap_DSampleAccNUHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_version", _wrap_DSampleAccNUHistoND_version, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_read", _wrap_DSampleAccNUHistoND_read, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_examine", _wrap_DSampleAccNUHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_closestBin", _wrap_DSampleAccNUHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_setBin", _wrap_DSampleAccNUHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_setLinearBin", _wrap_DSampleAccNUHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_setBinsToConst", _wrap_DSampleAccNUHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_setOverflowsToConst", _wrap_DSampleAccNUHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_fill", _wrap_DSampleAccNUHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_DSampleAccNUHistoND", _wrap_delete_DSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"DSampleAccNUHistoND_swigregister", DSampleAccNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DWSampleAccNUHistoND", _wrap_new_DWSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_dim", _wrap_DWSampleAccNUHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_title", _wrap_DWSampleAccNUHistoND_title, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_accumulatedDataLabel", _wrap_DWSampleAccNUHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_binContents", _wrap_DWSampleAccNUHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_overflows", _wrap_DWSampleAccNUHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_axes", _wrap_DWSampleAccNUHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_axis", _wrap_DWSampleAccNUHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_nBins", _wrap_DWSampleAccNUHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_nFillsTotal", _wrap_DWSampleAccNUHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_nFillsInRange", _wrap_DWSampleAccNUHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_nFillsOver", _wrap_DWSampleAccNUHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_isUniformlyBinned", _wrap_DWSampleAccNUHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_setTitle", _wrap_DWSampleAccNUHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_setAccumulatedDataLabel", _wrap_DWSampleAccNUHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_setAxisLabel", _wrap_DWSampleAccNUHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_binVolume", _wrap_DWSampleAccNUHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_binCenter", _wrap_DWSampleAccNUHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_binBox", _wrap_DWSampleAccNUHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_boundingBox", _wrap_DWSampleAccNUHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_volume", _wrap_DWSampleAccNUHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_clear", _wrap_DWSampleAccNUHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_clearBinContents", _wrap_DWSampleAccNUHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_clearOverflows", _wrap_DWSampleAccNUHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND___eq__", _wrap_DWSampleAccNUHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND___ne__", _wrap_DWSampleAccNUHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_isSameData", _wrap_DWSampleAccNUHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_setNFillsTotal", _wrap_DWSampleAccNUHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_setNFillsOver", _wrap_DWSampleAccNUHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_transpose", _wrap_DWSampleAccNUHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_getModCount", _wrap_DWSampleAccNUHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_incrModCount", _wrap_DWSampleAccNUHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_classId", _wrap_DWSampleAccNUHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_write", _wrap_DWSampleAccNUHistoND_write, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_classname", _wrap_DWSampleAccNUHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_version", _wrap_DWSampleAccNUHistoND_version, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_read", _wrap_DWSampleAccNUHistoND_read, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_examine", _wrap_DWSampleAccNUHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_closestBin", _wrap_DWSampleAccNUHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_setBin", _wrap_DWSampleAccNUHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_setLinearBin", _wrap_DWSampleAccNUHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_setBinsToConst", _wrap_DWSampleAccNUHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_setOverflowsToConst", _wrap_DWSampleAccNUHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_fill", _wrap_DWSampleAccNUHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_DWSampleAccNUHistoND", _wrap_delete_DWSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccNUHistoND_swigregister", DWSampleAccNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntDAHistoND", _wrap_new_IntDAHistoND, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_dim", _wrap_IntDAHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_title", _wrap_IntDAHistoND_title, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_accumulatedDataLabel", _wrap_IntDAHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_binContents", _wrap_IntDAHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_overflows", _wrap_IntDAHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_axes", _wrap_IntDAHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_axis", _wrap_IntDAHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_nBins", _wrap_IntDAHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_nFillsTotal", _wrap_IntDAHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_nFillsInRange", _wrap_IntDAHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_nFillsOver", _wrap_IntDAHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_isUniformlyBinned", _wrap_IntDAHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_setTitle", _wrap_IntDAHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_setAccumulatedDataLabel", _wrap_IntDAHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_setAxisLabel", _wrap_IntDAHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_binVolume", _wrap_IntDAHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_binCenter", _wrap_IntDAHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_binBox", _wrap_IntDAHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_boundingBox", _wrap_IntDAHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_volume", _wrap_IntDAHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_integral", _wrap_IntDAHistoND_integral, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_clear", _wrap_IntDAHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_clearBinContents", _wrap_IntDAHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_clearOverflows", _wrap_IntDAHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND___eq__", _wrap_IntDAHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND___ne__", _wrap_IntDAHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_isSameData", _wrap_IntDAHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_recalculateNFillsFromData", _wrap_IntDAHistoND_recalculateNFillsFromData, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_setNFillsTotal", _wrap_IntDAHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_setNFillsOver", _wrap_IntDAHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_transpose", _wrap_IntDAHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_getModCount", _wrap_IntDAHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_incrModCount", _wrap_IntDAHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_classId", _wrap_IntDAHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_write", _wrap_IntDAHistoND_write, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_classname", _wrap_IntDAHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_version", _wrap_IntDAHistoND_version, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_read", _wrap_IntDAHistoND_read, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_examine", _wrap_IntDAHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_closestBin", _wrap_IntDAHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_setBin", _wrap_IntDAHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_setLinearBin", _wrap_IntDAHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_setBinsToConst", _wrap_IntDAHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_setOverflowsToConst", _wrap_IntDAHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_fill", _wrap_IntDAHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_IntDAHistoND", _wrap_delete_IntDAHistoND, METH_VARARGS, NULL},
	{ (char *)"IntDAHistoND_swigregister", IntDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongDAHistoND", _wrap_new_LLongDAHistoND, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_dim", _wrap_LLongDAHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_title", _wrap_LLongDAHistoND_title, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_accumulatedDataLabel", _wrap_LLongDAHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_binContents", _wrap_LLongDAHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_overflows", _wrap_LLongDAHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_axes", _wrap_LLongDAHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_axis", _wrap_LLongDAHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_nBins", _wrap_LLongDAHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_nFillsTotal", _wrap_LLongDAHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_nFillsInRange", _wrap_LLongDAHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_nFillsOver", _wrap_LLongDAHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_isUniformlyBinned", _wrap_LLongDAHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_setTitle", _wrap_LLongDAHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_setAccumulatedDataLabel", _wrap_LLongDAHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_setAxisLabel", _wrap_LLongDAHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_binVolume", _wrap_LLongDAHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_binCenter", _wrap_LLongDAHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_binBox", _wrap_LLongDAHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_boundingBox", _wrap_LLongDAHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_volume", _wrap_LLongDAHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_integral", _wrap_LLongDAHistoND_integral, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_clear", _wrap_LLongDAHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_clearBinContents", _wrap_LLongDAHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_clearOverflows", _wrap_LLongDAHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND___eq__", _wrap_LLongDAHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND___ne__", _wrap_LLongDAHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_isSameData", _wrap_LLongDAHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_recalculateNFillsFromData", _wrap_LLongDAHistoND_recalculateNFillsFromData, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_setNFillsTotal", _wrap_LLongDAHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_setNFillsOver", _wrap_LLongDAHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_transpose", _wrap_LLongDAHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_getModCount", _wrap_LLongDAHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_incrModCount", _wrap_LLongDAHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_classId", _wrap_LLongDAHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_write", _wrap_LLongDAHistoND_write, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_classname", _wrap_LLongDAHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_version", _wrap_LLongDAHistoND_version, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_read", _wrap_LLongDAHistoND_read, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_examine", _wrap_LLongDAHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_closestBin", _wrap_LLongDAHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_setBin", _wrap_LLongDAHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_setLinearBin", _wrap_LLongDAHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_setBinsToConst", _wrap_LLongDAHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_setOverflowsToConst", _wrap_LLongDAHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_fill", _wrap_LLongDAHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_LLongDAHistoND", _wrap_delete_LLongDAHistoND, METH_VARARGS, NULL},
	{ (char *)"LLongDAHistoND_swigregister", LLongDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharDAHistoND", _wrap_new_UCharDAHistoND, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_dim", _wrap_UCharDAHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_title", _wrap_UCharDAHistoND_title, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_accumulatedDataLabel", _wrap_UCharDAHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_binContents", _wrap_UCharDAHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_overflows", _wrap_UCharDAHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_axes", _wrap_UCharDAHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_axis", _wrap_UCharDAHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_nBins", _wrap_UCharDAHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_nFillsTotal", _wrap_UCharDAHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_nFillsInRange", _wrap_UCharDAHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_nFillsOver", _wrap_UCharDAHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_isUniformlyBinned", _wrap_UCharDAHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_setTitle", _wrap_UCharDAHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_setAccumulatedDataLabel", _wrap_UCharDAHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_setAxisLabel", _wrap_UCharDAHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_binVolume", _wrap_UCharDAHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_binCenter", _wrap_UCharDAHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_binBox", _wrap_UCharDAHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_boundingBox", _wrap_UCharDAHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_volume", _wrap_UCharDAHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_integral", _wrap_UCharDAHistoND_integral, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_clear", _wrap_UCharDAHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_clearBinContents", _wrap_UCharDAHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_clearOverflows", _wrap_UCharDAHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND___eq__", _wrap_UCharDAHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND___ne__", _wrap_UCharDAHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_isSameData", _wrap_UCharDAHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_recalculateNFillsFromData", _wrap_UCharDAHistoND_recalculateNFillsFromData, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_setNFillsTotal", _wrap_UCharDAHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_setNFillsOver", _wrap_UCharDAHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_transpose", _wrap_UCharDAHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_getModCount", _wrap_UCharDAHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_incrModCount", _wrap_UCharDAHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_classId", _wrap_UCharDAHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_write", _wrap_UCharDAHistoND_write, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_classname", _wrap_UCharDAHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_version", _wrap_UCharDAHistoND_version, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_read", _wrap_UCharDAHistoND_read, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_examine", _wrap_UCharDAHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_closestBin", _wrap_UCharDAHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_setBin", _wrap_UCharDAHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_setLinearBin", _wrap_UCharDAHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_setBinsToConst", _wrap_UCharDAHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_setOverflowsToConst", _wrap_UCharDAHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_fill", _wrap_UCharDAHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_UCharDAHistoND", _wrap_delete_UCharDAHistoND, METH_VARARGS, NULL},
	{ (char *)"UCharDAHistoND_swigregister", UCharDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatDAHistoND", _wrap_new_FloatDAHistoND, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_dim", _wrap_FloatDAHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_title", _wrap_FloatDAHistoND_title, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_accumulatedDataLabel", _wrap_FloatDAHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_binContents", _wrap_FloatDAHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_overflows", _wrap_FloatDAHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_axes", _wrap_FloatDAHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_axis", _wrap_FloatDAHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_nBins", _wrap_FloatDAHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_nFillsTotal", _wrap_FloatDAHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_nFillsInRange", _wrap_FloatDAHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_nFillsOver", _wrap_FloatDAHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_isUniformlyBinned", _wrap_FloatDAHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_setTitle", _wrap_FloatDAHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_setAccumulatedDataLabel", _wrap_FloatDAHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_setAxisLabel", _wrap_FloatDAHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_binVolume", _wrap_FloatDAHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_binCenter", _wrap_FloatDAHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_binBox", _wrap_FloatDAHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_boundingBox", _wrap_FloatDAHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_volume", _wrap_FloatDAHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_integral", _wrap_FloatDAHistoND_integral, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_clear", _wrap_FloatDAHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_clearBinContents", _wrap_FloatDAHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_clearOverflows", _wrap_FloatDAHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND___eq__", _wrap_FloatDAHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND___ne__", _wrap_FloatDAHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_isSameData", _wrap_FloatDAHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_recalculateNFillsFromData", _wrap_FloatDAHistoND_recalculateNFillsFromData, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_setNFillsTotal", _wrap_FloatDAHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_setNFillsOver", _wrap_FloatDAHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_transpose", _wrap_FloatDAHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_getModCount", _wrap_FloatDAHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_incrModCount", _wrap_FloatDAHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_classId", _wrap_FloatDAHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_write", _wrap_FloatDAHistoND_write, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_classname", _wrap_FloatDAHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_version", _wrap_FloatDAHistoND_version, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_read", _wrap_FloatDAHistoND_read, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_examine", _wrap_FloatDAHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_closestBin", _wrap_FloatDAHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_setBin", _wrap_FloatDAHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_setLinearBin", _wrap_FloatDAHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_setBinsToConst", _wrap_FloatDAHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_setOverflowsToConst", _wrap_FloatDAHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_fill", _wrap_FloatDAHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_FloatDAHistoND", _wrap_delete_FloatDAHistoND, METH_VARARGS, NULL},
	{ (char *)"FloatDAHistoND_swigregister", FloatDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleDAHistoND", _wrap_new_DoubleDAHistoND, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_dim", _wrap_DoubleDAHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_title", _wrap_DoubleDAHistoND_title, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_accumulatedDataLabel", _wrap_DoubleDAHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_binContents", _wrap_DoubleDAHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_overflows", _wrap_DoubleDAHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_axes", _wrap_DoubleDAHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_axis", _wrap_DoubleDAHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_nBins", _wrap_DoubleDAHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_nFillsTotal", _wrap_DoubleDAHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_nFillsInRange", _wrap_DoubleDAHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_nFillsOver", _wrap_DoubleDAHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_isUniformlyBinned", _wrap_DoubleDAHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_setTitle", _wrap_DoubleDAHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_setAccumulatedDataLabel", _wrap_DoubleDAHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_setAxisLabel", _wrap_DoubleDAHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_binVolume", _wrap_DoubleDAHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_binCenter", _wrap_DoubleDAHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_binBox", _wrap_DoubleDAHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_boundingBox", _wrap_DoubleDAHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_volume", _wrap_DoubleDAHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_integral", _wrap_DoubleDAHistoND_integral, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_clear", _wrap_DoubleDAHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_clearBinContents", _wrap_DoubleDAHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_clearOverflows", _wrap_DoubleDAHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND___eq__", _wrap_DoubleDAHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND___ne__", _wrap_DoubleDAHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_isSameData", _wrap_DoubleDAHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_recalculateNFillsFromData", _wrap_DoubleDAHistoND_recalculateNFillsFromData, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_setNFillsTotal", _wrap_DoubleDAHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_setNFillsOver", _wrap_DoubleDAHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_transpose", _wrap_DoubleDAHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_getModCount", _wrap_DoubleDAHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_incrModCount", _wrap_DoubleDAHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_classId", _wrap_DoubleDAHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_write", _wrap_DoubleDAHistoND_write, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_classname", _wrap_DoubleDAHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_version", _wrap_DoubleDAHistoND_version, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_read", _wrap_DoubleDAHistoND_read, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_examine", _wrap_DoubleDAHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_closestBin", _wrap_DoubleDAHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_setBin", _wrap_DoubleDAHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_setLinearBin", _wrap_DoubleDAHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_setBinsToConst", _wrap_DoubleDAHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_setOverflowsToConst", _wrap_DoubleDAHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_fill", _wrap_DoubleDAHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleDAHistoND", _wrap_delete_DoubleDAHistoND, METH_VARARGS, NULL},
	{ (char *)"DoubleDAHistoND_swigregister", DoubleDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_StatAccDAHistoND", _wrap_new_StatAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_dim", _wrap_StatAccDAHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_title", _wrap_StatAccDAHistoND_title, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_accumulatedDataLabel", _wrap_StatAccDAHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_binContents", _wrap_StatAccDAHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_overflows", _wrap_StatAccDAHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_axes", _wrap_StatAccDAHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_axis", _wrap_StatAccDAHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_nBins", _wrap_StatAccDAHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_nFillsTotal", _wrap_StatAccDAHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_nFillsInRange", _wrap_StatAccDAHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_nFillsOver", _wrap_StatAccDAHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_isUniformlyBinned", _wrap_StatAccDAHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_setTitle", _wrap_StatAccDAHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_setAccumulatedDataLabel", _wrap_StatAccDAHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_setAxisLabel", _wrap_StatAccDAHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_binVolume", _wrap_StatAccDAHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_binCenter", _wrap_StatAccDAHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_binBox", _wrap_StatAccDAHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_boundingBox", _wrap_StatAccDAHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_volume", _wrap_StatAccDAHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_clear", _wrap_StatAccDAHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_clearBinContents", _wrap_StatAccDAHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_clearOverflows", _wrap_StatAccDAHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND___eq__", _wrap_StatAccDAHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND___ne__", _wrap_StatAccDAHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_isSameData", _wrap_StatAccDAHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_setNFillsTotal", _wrap_StatAccDAHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_setNFillsOver", _wrap_StatAccDAHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_transpose", _wrap_StatAccDAHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_getModCount", _wrap_StatAccDAHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_incrModCount", _wrap_StatAccDAHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_classId", _wrap_StatAccDAHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_write", _wrap_StatAccDAHistoND_write, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_classname", _wrap_StatAccDAHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_version", _wrap_StatAccDAHistoND_version, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_read", _wrap_StatAccDAHistoND_read, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_examine", _wrap_StatAccDAHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_closestBin", _wrap_StatAccDAHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_setBin", _wrap_StatAccDAHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_setLinearBin", _wrap_StatAccDAHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_setBinsToConst", _wrap_StatAccDAHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_setOverflowsToConst", _wrap_StatAccDAHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_fill", _wrap_StatAccDAHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_StatAccDAHistoND", _wrap_delete_StatAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"StatAccDAHistoND_swigregister", StatAccDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_WStatAccDAHistoND", _wrap_new_WStatAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_dim", _wrap_WStatAccDAHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_title", _wrap_WStatAccDAHistoND_title, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_accumulatedDataLabel", _wrap_WStatAccDAHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_binContents", _wrap_WStatAccDAHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_overflows", _wrap_WStatAccDAHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_axes", _wrap_WStatAccDAHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_axis", _wrap_WStatAccDAHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_nBins", _wrap_WStatAccDAHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_nFillsTotal", _wrap_WStatAccDAHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_nFillsInRange", _wrap_WStatAccDAHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_nFillsOver", _wrap_WStatAccDAHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_isUniformlyBinned", _wrap_WStatAccDAHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_setTitle", _wrap_WStatAccDAHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_setAccumulatedDataLabel", _wrap_WStatAccDAHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_setAxisLabel", _wrap_WStatAccDAHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_binVolume", _wrap_WStatAccDAHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_binCenter", _wrap_WStatAccDAHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_binBox", _wrap_WStatAccDAHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_boundingBox", _wrap_WStatAccDAHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_volume", _wrap_WStatAccDAHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_clear", _wrap_WStatAccDAHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_clearBinContents", _wrap_WStatAccDAHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_clearOverflows", _wrap_WStatAccDAHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND___eq__", _wrap_WStatAccDAHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND___ne__", _wrap_WStatAccDAHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_isSameData", _wrap_WStatAccDAHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_setNFillsTotal", _wrap_WStatAccDAHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_setNFillsOver", _wrap_WStatAccDAHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_transpose", _wrap_WStatAccDAHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_getModCount", _wrap_WStatAccDAHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_incrModCount", _wrap_WStatAccDAHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_classId", _wrap_WStatAccDAHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_write", _wrap_WStatAccDAHistoND_write, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_classname", _wrap_WStatAccDAHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_version", _wrap_WStatAccDAHistoND_version, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_read", _wrap_WStatAccDAHistoND_read, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_examine", _wrap_WStatAccDAHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_closestBin", _wrap_WStatAccDAHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_setBin", _wrap_WStatAccDAHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_setLinearBin", _wrap_WStatAccDAHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_setBinsToConst", _wrap_WStatAccDAHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_setOverflowsToConst", _wrap_WStatAccDAHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_fill", _wrap_WStatAccDAHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_WStatAccDAHistoND", _wrap_delete_WStatAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"WStatAccDAHistoND_swigregister", WStatAccDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_BinSummaryDAHistoND", _wrap_new_BinSummaryDAHistoND, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_dim", _wrap_BinSummaryDAHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_title", _wrap_BinSummaryDAHistoND_title, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_accumulatedDataLabel", _wrap_BinSummaryDAHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_binContents", _wrap_BinSummaryDAHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_overflows", _wrap_BinSummaryDAHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_axes", _wrap_BinSummaryDAHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_axis", _wrap_BinSummaryDAHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_nBins", _wrap_BinSummaryDAHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_nFillsTotal", _wrap_BinSummaryDAHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_nFillsInRange", _wrap_BinSummaryDAHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_nFillsOver", _wrap_BinSummaryDAHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_isUniformlyBinned", _wrap_BinSummaryDAHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_setTitle", _wrap_BinSummaryDAHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_setAccumulatedDataLabel", _wrap_BinSummaryDAHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_setAxisLabel", _wrap_BinSummaryDAHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_binVolume", _wrap_BinSummaryDAHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_binCenter", _wrap_BinSummaryDAHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_binBox", _wrap_BinSummaryDAHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_boundingBox", _wrap_BinSummaryDAHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_volume", _wrap_BinSummaryDAHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_clear", _wrap_BinSummaryDAHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_clearBinContents", _wrap_BinSummaryDAHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_clearOverflows", _wrap_BinSummaryDAHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND___eq__", _wrap_BinSummaryDAHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND___ne__", _wrap_BinSummaryDAHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_isSameData", _wrap_BinSummaryDAHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_setNFillsTotal", _wrap_BinSummaryDAHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_setNFillsOver", _wrap_BinSummaryDAHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_transpose", _wrap_BinSummaryDAHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_getModCount", _wrap_BinSummaryDAHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_incrModCount", _wrap_BinSummaryDAHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_classId", _wrap_BinSummaryDAHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_write", _wrap_BinSummaryDAHistoND_write, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_classname", _wrap_BinSummaryDAHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_version", _wrap_BinSummaryDAHistoND_version, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_read", _wrap_BinSummaryDAHistoND_read, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_examine", _wrap_BinSummaryDAHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_closestBin", _wrap_BinSummaryDAHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_setBin", _wrap_BinSummaryDAHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_setLinearBin", _wrap_BinSummaryDAHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_setBinsToConst", _wrap_BinSummaryDAHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_setOverflowsToConst", _wrap_BinSummaryDAHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_fill", _wrap_BinSummaryDAHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_BinSummaryDAHistoND", _wrap_delete_BinSummaryDAHistoND, METH_VARARGS, NULL},
	{ (char *)"BinSummaryDAHistoND_swigregister", BinSummaryDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FSampleAccDAHistoND", _wrap_new_FSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_dim", _wrap_FSampleAccDAHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_title", _wrap_FSampleAccDAHistoND_title, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_accumulatedDataLabel", _wrap_FSampleAccDAHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_binContents", _wrap_FSampleAccDAHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_overflows", _wrap_FSampleAccDAHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_axes", _wrap_FSampleAccDAHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_axis", _wrap_FSampleAccDAHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_nBins", _wrap_FSampleAccDAHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_nFillsTotal", _wrap_FSampleAccDAHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_nFillsInRange", _wrap_FSampleAccDAHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_nFillsOver", _wrap_FSampleAccDAHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_isUniformlyBinned", _wrap_FSampleAccDAHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_setTitle", _wrap_FSampleAccDAHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_setAccumulatedDataLabel", _wrap_FSampleAccDAHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_setAxisLabel", _wrap_FSampleAccDAHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_binVolume", _wrap_FSampleAccDAHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_binCenter", _wrap_FSampleAccDAHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_binBox", _wrap_FSampleAccDAHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_boundingBox", _wrap_FSampleAccDAHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_volume", _wrap_FSampleAccDAHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_clear", _wrap_FSampleAccDAHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_clearBinContents", _wrap_FSampleAccDAHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_clearOverflows", _wrap_FSampleAccDAHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND___eq__", _wrap_FSampleAccDAHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND___ne__", _wrap_FSampleAccDAHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_isSameData", _wrap_FSampleAccDAHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_setNFillsTotal", _wrap_FSampleAccDAHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_setNFillsOver", _wrap_FSampleAccDAHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_transpose", _wrap_FSampleAccDAHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_getModCount", _wrap_FSampleAccDAHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_incrModCount", _wrap_FSampleAccDAHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_classId", _wrap_FSampleAccDAHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_write", _wrap_FSampleAccDAHistoND_write, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_classname", _wrap_FSampleAccDAHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_version", _wrap_FSampleAccDAHistoND_version, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_read", _wrap_FSampleAccDAHistoND_read, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_examine", _wrap_FSampleAccDAHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_closestBin", _wrap_FSampleAccDAHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_setBin", _wrap_FSampleAccDAHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_setLinearBin", _wrap_FSampleAccDAHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_setBinsToConst", _wrap_FSampleAccDAHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_setOverflowsToConst", _wrap_FSampleAccDAHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_fill", _wrap_FSampleAccDAHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_FSampleAccDAHistoND", _wrap_delete_FSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"FSampleAccDAHistoND_swigregister", FSampleAccDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DSampleAccDAHistoND", _wrap_new_DSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_dim", _wrap_DSampleAccDAHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_title", _wrap_DSampleAccDAHistoND_title, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_accumulatedDataLabel", _wrap_DSampleAccDAHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_binContents", _wrap_DSampleAccDAHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_overflows", _wrap_DSampleAccDAHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_axes", _wrap_DSampleAccDAHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_axis", _wrap_DSampleAccDAHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_nBins", _wrap_DSampleAccDAHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_nFillsTotal", _wrap_DSampleAccDAHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_nFillsInRange", _wrap_DSampleAccDAHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_nFillsOver", _wrap_DSampleAccDAHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_isUniformlyBinned", _wrap_DSampleAccDAHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_setTitle", _wrap_DSampleAccDAHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_setAccumulatedDataLabel", _wrap_DSampleAccDAHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_setAxisLabel", _wrap_DSampleAccDAHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_binVolume", _wrap_DSampleAccDAHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_binCenter", _wrap_DSampleAccDAHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_binBox", _wrap_DSampleAccDAHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_boundingBox", _wrap_DSampleAccDAHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_volume", _wrap_DSampleAccDAHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_clear", _wrap_DSampleAccDAHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_clearBinContents", _wrap_DSampleAccDAHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_clearOverflows", _wrap_DSampleAccDAHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND___eq__", _wrap_DSampleAccDAHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND___ne__", _wrap_DSampleAccDAHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_isSameData", _wrap_DSampleAccDAHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_setNFillsTotal", _wrap_DSampleAccDAHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_setNFillsOver", _wrap_DSampleAccDAHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_transpose", _wrap_DSampleAccDAHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_getModCount", _wrap_DSampleAccDAHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_incrModCount", _wrap_DSampleAccDAHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_classId", _wrap_DSampleAccDAHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_write", _wrap_DSampleAccDAHistoND_write, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_classname", _wrap_DSampleAccDAHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_version", _wrap_DSampleAccDAHistoND_version, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_read", _wrap_DSampleAccDAHistoND_read, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_examine", _wrap_DSampleAccDAHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_closestBin", _wrap_DSampleAccDAHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_setBin", _wrap_DSampleAccDAHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_setLinearBin", _wrap_DSampleAccDAHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_setBinsToConst", _wrap_DSampleAccDAHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_setOverflowsToConst", _wrap_DSampleAccDAHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_fill", _wrap_DSampleAccDAHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_DSampleAccDAHistoND", _wrap_delete_DSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"DSampleAccDAHistoND_swigregister", DSampleAccDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DWSampleAccDAHistoND", _wrap_new_DWSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_dim", _wrap_DWSampleAccDAHistoND_dim, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_title", _wrap_DWSampleAccDAHistoND_title, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_accumulatedDataLabel", _wrap_DWSampleAccDAHistoND_accumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_binContents", _wrap_DWSampleAccDAHistoND_binContents, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_overflows", _wrap_DWSampleAccDAHistoND_overflows, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_axes", _wrap_DWSampleAccDAHistoND_axes, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_axis", _wrap_DWSampleAccDAHistoND_axis, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_nBins", _wrap_DWSampleAccDAHistoND_nBins, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_nFillsTotal", _wrap_DWSampleAccDAHistoND_nFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_nFillsInRange", _wrap_DWSampleAccDAHistoND_nFillsInRange, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_nFillsOver", _wrap_DWSampleAccDAHistoND_nFillsOver, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_isUniformlyBinned", _wrap_DWSampleAccDAHistoND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_setTitle", _wrap_DWSampleAccDAHistoND_setTitle, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_setAccumulatedDataLabel", _wrap_DWSampleAccDAHistoND_setAccumulatedDataLabel, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_setAxisLabel", _wrap_DWSampleAccDAHistoND_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_binVolume", _wrap_DWSampleAccDAHistoND_binVolume, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_binCenter", _wrap_DWSampleAccDAHistoND_binCenter, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_binBox", _wrap_DWSampleAccDAHistoND_binBox, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_boundingBox", _wrap_DWSampleAccDAHistoND_boundingBox, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_volume", _wrap_DWSampleAccDAHistoND_volume, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_clear", _wrap_DWSampleAccDAHistoND_clear, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_clearBinContents", _wrap_DWSampleAccDAHistoND_clearBinContents, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_clearOverflows", _wrap_DWSampleAccDAHistoND_clearOverflows, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND___eq__", _wrap_DWSampleAccDAHistoND___eq__, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND___ne__", _wrap_DWSampleAccDAHistoND___ne__, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_isSameData", _wrap_DWSampleAccDAHistoND_isSameData, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_setNFillsTotal", _wrap_DWSampleAccDAHistoND_setNFillsTotal, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_setNFillsOver", _wrap_DWSampleAccDAHistoND_setNFillsOver, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_transpose", _wrap_DWSampleAccDAHistoND_transpose, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_getModCount", _wrap_DWSampleAccDAHistoND_getModCount, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_incrModCount", _wrap_DWSampleAccDAHistoND_incrModCount, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_classId", _wrap_DWSampleAccDAHistoND_classId, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_write", _wrap_DWSampleAccDAHistoND_write, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_classname", _wrap_DWSampleAccDAHistoND_classname, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_version", _wrap_DWSampleAccDAHistoND_version, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_read", _wrap_DWSampleAccDAHistoND_read, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_examine", _wrap_DWSampleAccDAHistoND_examine, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_closestBin", _wrap_DWSampleAccDAHistoND_closestBin, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_setBin", _wrap_DWSampleAccDAHistoND_setBin, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_setLinearBin", _wrap_DWSampleAccDAHistoND_setLinearBin, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_setBinsToConst", _wrap_DWSampleAccDAHistoND_setBinsToConst, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_setOverflowsToConst", _wrap_DWSampleAccDAHistoND_setOverflowsToConst, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_fill", _wrap_DWSampleAccDAHistoND_fill, METH_VARARGS, NULL},
	{ (char *)"delete_DWSampleAccDAHistoND", _wrap_delete_DWSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"DWSampleAccDAHistoND_swigregister", DWSampleAccDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_UCharHistoND", _wrap_new_ArchiveRecord_UCharHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_UCharHistoND", _wrap_delete_ArchiveRecord_UCharHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_UCharHistoND_swigregister", ArchiveRecord_UCharHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_UCharHistoND", _wrap_new_Ref_UCharHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharHistoND_restore", _wrap_Ref_UCharHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharHistoND_retrieve", _wrap_Ref_UCharHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharHistoND_getValue", _wrap_Ref_UCharHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_UCharHistoND", _wrap_delete_Ref_UCharHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharHistoND_swigregister", Ref_UCharHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_UCharNUHistoND", _wrap_new_ArchiveRecord_UCharNUHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_UCharNUHistoND", _wrap_delete_ArchiveRecord_UCharNUHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_UCharNUHistoND_swigregister", ArchiveRecord_UCharNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_UCharNUHistoND", _wrap_new_Ref_UCharNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharNUHistoND_restore", _wrap_Ref_UCharNUHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharNUHistoND_retrieve", _wrap_Ref_UCharNUHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharNUHistoND_getValue", _wrap_Ref_UCharNUHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_UCharNUHistoND", _wrap_delete_Ref_UCharNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharNUHistoND_swigregister", Ref_UCharNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_UCharDAHistoND", _wrap_new_ArchiveRecord_UCharDAHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_UCharDAHistoND", _wrap_delete_ArchiveRecord_UCharDAHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_UCharDAHistoND_swigregister", ArchiveRecord_UCharDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_UCharDAHistoND", _wrap_new_Ref_UCharDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharDAHistoND_restore", _wrap_Ref_UCharDAHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharDAHistoND_retrieve", _wrap_Ref_UCharDAHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharDAHistoND_getValue", _wrap_Ref_UCharDAHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_UCharDAHistoND", _wrap_delete_Ref_UCharDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharDAHistoND_swigregister", Ref_UCharDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_IntHistoND", _wrap_new_ArchiveRecord_IntHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_IntHistoND", _wrap_delete_ArchiveRecord_IntHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_IntHistoND_swigregister", ArchiveRecord_IntHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_IntHistoND", _wrap_new_Ref_IntHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_IntHistoND_restore", _wrap_Ref_IntHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_IntHistoND_retrieve", _wrap_Ref_IntHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_IntHistoND_getValue", _wrap_Ref_IntHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_IntHistoND", _wrap_delete_Ref_IntHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_IntHistoND_swigregister", Ref_IntHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_IntNUHistoND", _wrap_new_ArchiveRecord_IntNUHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_IntNUHistoND", _wrap_delete_ArchiveRecord_IntNUHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_IntNUHistoND_swigregister", ArchiveRecord_IntNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_IntNUHistoND", _wrap_new_Ref_IntNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_IntNUHistoND_restore", _wrap_Ref_IntNUHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_IntNUHistoND_retrieve", _wrap_Ref_IntNUHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_IntNUHistoND_getValue", _wrap_Ref_IntNUHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_IntNUHistoND", _wrap_delete_Ref_IntNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_IntNUHistoND_swigregister", Ref_IntNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_IntDAHistoND", _wrap_new_ArchiveRecord_IntDAHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_IntDAHistoND", _wrap_delete_ArchiveRecord_IntDAHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_IntDAHistoND_swigregister", ArchiveRecord_IntDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_IntDAHistoND", _wrap_new_Ref_IntDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_IntDAHistoND_restore", _wrap_Ref_IntDAHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_IntDAHistoND_retrieve", _wrap_Ref_IntDAHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_IntDAHistoND_getValue", _wrap_Ref_IntDAHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_IntDAHistoND", _wrap_delete_Ref_IntDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_IntDAHistoND_swigregister", Ref_IntDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_LLongHistoND", _wrap_new_ArchiveRecord_LLongHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_LLongHistoND", _wrap_delete_ArchiveRecord_LLongHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_LLongHistoND_swigregister", ArchiveRecord_LLongHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_LLongHistoND", _wrap_new_Ref_LLongHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongHistoND_restore", _wrap_Ref_LLongHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongHistoND_retrieve", _wrap_Ref_LLongHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongHistoND_getValue", _wrap_Ref_LLongHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_LLongHistoND", _wrap_delete_Ref_LLongHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongHistoND_swigregister", Ref_LLongHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_LLongNUHistoND", _wrap_new_ArchiveRecord_LLongNUHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_LLongNUHistoND", _wrap_delete_ArchiveRecord_LLongNUHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_LLongNUHistoND_swigregister", ArchiveRecord_LLongNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_LLongNUHistoND", _wrap_new_Ref_LLongNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongNUHistoND_restore", _wrap_Ref_LLongNUHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongNUHistoND_retrieve", _wrap_Ref_LLongNUHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongNUHistoND_getValue", _wrap_Ref_LLongNUHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_LLongNUHistoND", _wrap_delete_Ref_LLongNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongNUHistoND_swigregister", Ref_LLongNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_LLongDAHistoND", _wrap_new_ArchiveRecord_LLongDAHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_LLongDAHistoND", _wrap_delete_ArchiveRecord_LLongDAHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_LLongDAHistoND_swigregister", ArchiveRecord_LLongDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_LLongDAHistoND", _wrap_new_Ref_LLongDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongDAHistoND_restore", _wrap_Ref_LLongDAHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongDAHistoND_retrieve", _wrap_Ref_LLongDAHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongDAHistoND_getValue", _wrap_Ref_LLongDAHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_LLongDAHistoND", _wrap_delete_Ref_LLongDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongDAHistoND_swigregister", Ref_LLongDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_FloatHistoND", _wrap_new_ArchiveRecord_FloatHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_FloatHistoND", _wrap_delete_ArchiveRecord_FloatHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_FloatHistoND_swigregister", ArchiveRecord_FloatHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_FloatHistoND", _wrap_new_Ref_FloatHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatHistoND_restore", _wrap_Ref_FloatHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatHistoND_retrieve", _wrap_Ref_FloatHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatHistoND_getValue", _wrap_Ref_FloatHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_FloatHistoND", _wrap_delete_Ref_FloatHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatHistoND_swigregister", Ref_FloatHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_FloatNUHistoND", _wrap_new_ArchiveRecord_FloatNUHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_FloatNUHistoND", _wrap_delete_ArchiveRecord_FloatNUHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_FloatNUHistoND_swigregister", ArchiveRecord_FloatNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_FloatNUHistoND", _wrap_new_Ref_FloatNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatNUHistoND_restore", _wrap_Ref_FloatNUHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatNUHistoND_retrieve", _wrap_Ref_FloatNUHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatNUHistoND_getValue", _wrap_Ref_FloatNUHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_FloatNUHistoND", _wrap_delete_Ref_FloatNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatNUHistoND_swigregister", Ref_FloatNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_FloatDAHistoND", _wrap_new_ArchiveRecord_FloatDAHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_FloatDAHistoND", _wrap_delete_ArchiveRecord_FloatDAHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_FloatDAHistoND_swigregister", ArchiveRecord_FloatDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_FloatDAHistoND", _wrap_new_Ref_FloatDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatDAHistoND_restore", _wrap_Ref_FloatDAHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatDAHistoND_retrieve", _wrap_Ref_FloatDAHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatDAHistoND_getValue", _wrap_Ref_FloatDAHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_FloatDAHistoND", _wrap_delete_Ref_FloatDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatDAHistoND_swigregister", Ref_FloatDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DoubleHistoND", _wrap_new_ArchiveRecord_DoubleHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DoubleHistoND", _wrap_delete_ArchiveRecord_DoubleHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DoubleHistoND_swigregister", ArchiveRecord_DoubleHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DoubleHistoND", _wrap_new_Ref_DoubleHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleHistoND_restore", _wrap_Ref_DoubleHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleHistoND_retrieve", _wrap_Ref_DoubleHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleHistoND_getValue", _wrap_Ref_DoubleHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DoubleHistoND", _wrap_delete_Ref_DoubleHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleHistoND_swigregister", Ref_DoubleHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DoubleNUHistoND", _wrap_new_ArchiveRecord_DoubleNUHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DoubleNUHistoND", _wrap_delete_ArchiveRecord_DoubleNUHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DoubleNUHistoND_swigregister", ArchiveRecord_DoubleNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DoubleNUHistoND", _wrap_new_Ref_DoubleNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleNUHistoND_restore", _wrap_Ref_DoubleNUHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleNUHistoND_retrieve", _wrap_Ref_DoubleNUHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleNUHistoND_getValue", _wrap_Ref_DoubleNUHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DoubleNUHistoND", _wrap_delete_Ref_DoubleNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleNUHistoND_swigregister", Ref_DoubleNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DoubleDAHistoND", _wrap_new_ArchiveRecord_DoubleDAHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DoubleDAHistoND", _wrap_delete_ArchiveRecord_DoubleDAHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DoubleDAHistoND_swigregister", ArchiveRecord_DoubleDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DoubleDAHistoND", _wrap_new_Ref_DoubleDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleDAHistoND_restore", _wrap_Ref_DoubleDAHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleDAHistoND_retrieve", _wrap_Ref_DoubleDAHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleDAHistoND_getValue", _wrap_Ref_DoubleDAHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DoubleDAHistoND", _wrap_delete_Ref_DoubleDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleDAHistoND_swigregister", Ref_DoubleDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_StatAccHistoND", _wrap_new_ArchiveRecord_StatAccHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_StatAccHistoND", _wrap_delete_ArchiveRecord_StatAccHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_StatAccHistoND_swigregister", ArchiveRecord_StatAccHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_StatAccHistoND", _wrap_new_Ref_StatAccHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_StatAccHistoND_restore", _wrap_Ref_StatAccHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_StatAccHistoND_retrieve", _wrap_Ref_StatAccHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_StatAccHistoND_getValue", _wrap_Ref_StatAccHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_StatAccHistoND", _wrap_delete_Ref_StatAccHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_StatAccHistoND_swigregister", Ref_StatAccHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_StatAccNUHistoND", _wrap_new_ArchiveRecord_StatAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_StatAccNUHistoND", _wrap_delete_ArchiveRecord_StatAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_StatAccNUHistoND_swigregister", ArchiveRecord_StatAccNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_StatAccNUHistoND", _wrap_new_Ref_StatAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_StatAccNUHistoND_restore", _wrap_Ref_StatAccNUHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_StatAccNUHistoND_retrieve", _wrap_Ref_StatAccNUHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_StatAccNUHistoND_getValue", _wrap_Ref_StatAccNUHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_StatAccNUHistoND", _wrap_delete_Ref_StatAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_StatAccNUHistoND_swigregister", Ref_StatAccNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_StatAccDAHistoND", _wrap_new_ArchiveRecord_StatAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_StatAccDAHistoND", _wrap_delete_ArchiveRecord_StatAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_StatAccDAHistoND_swigregister", ArchiveRecord_StatAccDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_StatAccDAHistoND", _wrap_new_Ref_StatAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_StatAccDAHistoND_restore", _wrap_Ref_StatAccDAHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_StatAccDAHistoND_retrieve", _wrap_Ref_StatAccDAHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_StatAccDAHistoND_getValue", _wrap_Ref_StatAccDAHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_StatAccDAHistoND", _wrap_delete_Ref_StatAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_StatAccDAHistoND_swigregister", Ref_StatAccDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_WStatAccHistoND", _wrap_new_ArchiveRecord_WStatAccHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_WStatAccHistoND", _wrap_delete_ArchiveRecord_WStatAccHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_WStatAccHistoND_swigregister", ArchiveRecord_WStatAccHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_WStatAccHistoND", _wrap_new_Ref_WStatAccHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_WStatAccHistoND_restore", _wrap_Ref_WStatAccHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_WStatAccHistoND_retrieve", _wrap_Ref_WStatAccHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_WStatAccHistoND_getValue", _wrap_Ref_WStatAccHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_WStatAccHistoND", _wrap_delete_Ref_WStatAccHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_WStatAccHistoND_swigregister", Ref_WStatAccHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_WStatAccNUHistoND", _wrap_new_ArchiveRecord_WStatAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_WStatAccNUHistoND", _wrap_delete_ArchiveRecord_WStatAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_WStatAccNUHistoND_swigregister", ArchiveRecord_WStatAccNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_WStatAccNUHistoND", _wrap_new_Ref_WStatAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_WStatAccNUHistoND_restore", _wrap_Ref_WStatAccNUHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_WStatAccNUHistoND_retrieve", _wrap_Ref_WStatAccNUHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_WStatAccNUHistoND_getValue", _wrap_Ref_WStatAccNUHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_WStatAccNUHistoND", _wrap_delete_Ref_WStatAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_WStatAccNUHistoND_swigregister", Ref_WStatAccNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_WStatAccDAHistoND", _wrap_new_ArchiveRecord_WStatAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_WStatAccDAHistoND", _wrap_delete_ArchiveRecord_WStatAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_WStatAccDAHistoND_swigregister", ArchiveRecord_WStatAccDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_WStatAccDAHistoND", _wrap_new_Ref_WStatAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_WStatAccDAHistoND_restore", _wrap_Ref_WStatAccDAHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_WStatAccDAHistoND_retrieve", _wrap_Ref_WStatAccDAHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_WStatAccDAHistoND_getValue", _wrap_Ref_WStatAccDAHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_WStatAccDAHistoND", _wrap_delete_Ref_WStatAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_WStatAccDAHistoND_swigregister", Ref_WStatAccDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_BinSummaryHistoND", _wrap_new_ArchiveRecord_BinSummaryHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_BinSummaryHistoND", _wrap_delete_ArchiveRecord_BinSummaryHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_BinSummaryHistoND_swigregister", ArchiveRecord_BinSummaryHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_BinSummaryHistoND", _wrap_new_Ref_BinSummaryHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_BinSummaryHistoND_restore", _wrap_Ref_BinSummaryHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_BinSummaryHistoND_retrieve", _wrap_Ref_BinSummaryHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_BinSummaryHistoND_getValue", _wrap_Ref_BinSummaryHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_BinSummaryHistoND", _wrap_delete_Ref_BinSummaryHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_BinSummaryHistoND_swigregister", Ref_BinSummaryHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_BinSummaryNUHistoND", _wrap_new_ArchiveRecord_BinSummaryNUHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_BinSummaryNUHistoND", _wrap_delete_ArchiveRecord_BinSummaryNUHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_BinSummaryNUHistoND_swigregister", ArchiveRecord_BinSummaryNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_BinSummaryNUHistoND", _wrap_new_Ref_BinSummaryNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_BinSummaryNUHistoND_restore", _wrap_Ref_BinSummaryNUHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_BinSummaryNUHistoND_retrieve", _wrap_Ref_BinSummaryNUHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_BinSummaryNUHistoND_getValue", _wrap_Ref_BinSummaryNUHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_BinSummaryNUHistoND", _wrap_delete_Ref_BinSummaryNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_BinSummaryNUHistoND_swigregister", Ref_BinSummaryNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_BinSummaryDAHistoND", _wrap_new_ArchiveRecord_BinSummaryDAHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_BinSummaryDAHistoND", _wrap_delete_ArchiveRecord_BinSummaryDAHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_BinSummaryDAHistoND_swigregister", ArchiveRecord_BinSummaryDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_BinSummaryDAHistoND", _wrap_new_Ref_BinSummaryDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_BinSummaryDAHistoND_restore", _wrap_Ref_BinSummaryDAHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_BinSummaryDAHistoND_retrieve", _wrap_Ref_BinSummaryDAHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_BinSummaryDAHistoND_getValue", _wrap_Ref_BinSummaryDAHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_BinSummaryDAHistoND", _wrap_delete_Ref_BinSummaryDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_BinSummaryDAHistoND_swigregister", Ref_BinSummaryDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_FSampleAccHistoND", _wrap_new_ArchiveRecord_FSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_FSampleAccHistoND", _wrap_delete_ArchiveRecord_FSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_FSampleAccHistoND_swigregister", ArchiveRecord_FSampleAccHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_FSampleAccHistoND", _wrap_new_Ref_FSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_FSampleAccHistoND_restore", _wrap_Ref_FSampleAccHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_FSampleAccHistoND_retrieve", _wrap_Ref_FSampleAccHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_FSampleAccHistoND_getValue", _wrap_Ref_FSampleAccHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_FSampleAccHistoND", _wrap_delete_Ref_FSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_FSampleAccHistoND_swigregister", Ref_FSampleAccHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_FSampleAccNUHistoND", _wrap_new_ArchiveRecord_FSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_FSampleAccNUHistoND", _wrap_delete_ArchiveRecord_FSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_FSampleAccNUHistoND_swigregister", ArchiveRecord_FSampleAccNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_FSampleAccNUHistoND", _wrap_new_Ref_FSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_FSampleAccNUHistoND_restore", _wrap_Ref_FSampleAccNUHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_FSampleAccNUHistoND_retrieve", _wrap_Ref_FSampleAccNUHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_FSampleAccNUHistoND_getValue", _wrap_Ref_FSampleAccNUHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_FSampleAccNUHistoND", _wrap_delete_Ref_FSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_FSampleAccNUHistoND_swigregister", Ref_FSampleAccNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_FSampleAccDAHistoND", _wrap_new_ArchiveRecord_FSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_FSampleAccDAHistoND", _wrap_delete_ArchiveRecord_FSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_FSampleAccDAHistoND_swigregister", ArchiveRecord_FSampleAccDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_FSampleAccDAHistoND", _wrap_new_Ref_FSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_FSampleAccDAHistoND_restore", _wrap_Ref_FSampleAccDAHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_FSampleAccDAHistoND_retrieve", _wrap_Ref_FSampleAccDAHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_FSampleAccDAHistoND_getValue", _wrap_Ref_FSampleAccDAHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_FSampleAccDAHistoND", _wrap_delete_Ref_FSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_FSampleAccDAHistoND_swigregister", Ref_FSampleAccDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DSampleAccHistoND", _wrap_new_ArchiveRecord_DSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DSampleAccHistoND", _wrap_delete_ArchiveRecord_DSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DSampleAccHistoND_swigregister", ArchiveRecord_DSampleAccHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DSampleAccHistoND", _wrap_new_Ref_DSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DSampleAccHistoND_restore", _wrap_Ref_DSampleAccHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DSampleAccHistoND_retrieve", _wrap_Ref_DSampleAccHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DSampleAccHistoND_getValue", _wrap_Ref_DSampleAccHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DSampleAccHistoND", _wrap_delete_Ref_DSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DSampleAccHistoND_swigregister", Ref_DSampleAccHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DSampleAccNUHistoND", _wrap_new_ArchiveRecord_DSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DSampleAccNUHistoND", _wrap_delete_ArchiveRecord_DSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DSampleAccNUHistoND_swigregister", ArchiveRecord_DSampleAccNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DSampleAccNUHistoND", _wrap_new_Ref_DSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DSampleAccNUHistoND_restore", _wrap_Ref_DSampleAccNUHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DSampleAccNUHistoND_retrieve", _wrap_Ref_DSampleAccNUHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DSampleAccNUHistoND_getValue", _wrap_Ref_DSampleAccNUHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DSampleAccNUHistoND", _wrap_delete_Ref_DSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DSampleAccNUHistoND_swigregister", Ref_DSampleAccNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DSampleAccDAHistoND", _wrap_new_ArchiveRecord_DSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DSampleAccDAHistoND", _wrap_delete_ArchiveRecord_DSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DSampleAccDAHistoND_swigregister", ArchiveRecord_DSampleAccDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DSampleAccDAHistoND", _wrap_new_Ref_DSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DSampleAccDAHistoND_restore", _wrap_Ref_DSampleAccDAHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DSampleAccDAHistoND_retrieve", _wrap_Ref_DSampleAccDAHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DSampleAccDAHistoND_getValue", _wrap_Ref_DSampleAccDAHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DSampleAccDAHistoND", _wrap_delete_Ref_DSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DSampleAccDAHistoND_swigregister", Ref_DSampleAccDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DWSampleAccHistoND", _wrap_new_ArchiveRecord_DWSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DWSampleAccHistoND", _wrap_delete_ArchiveRecord_DWSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DWSampleAccHistoND_swigregister", ArchiveRecord_DWSampleAccHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DWSampleAccHistoND", _wrap_new_Ref_DWSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DWSampleAccHistoND_restore", _wrap_Ref_DWSampleAccHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DWSampleAccHistoND_retrieve", _wrap_Ref_DWSampleAccHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DWSampleAccHistoND_getValue", _wrap_Ref_DWSampleAccHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DWSampleAccHistoND", _wrap_delete_Ref_DWSampleAccHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DWSampleAccHistoND_swigregister", Ref_DWSampleAccHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DWSampleAccNUHistoND", _wrap_new_ArchiveRecord_DWSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DWSampleAccNUHistoND", _wrap_delete_ArchiveRecord_DWSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DWSampleAccNUHistoND_swigregister", ArchiveRecord_DWSampleAccNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DWSampleAccNUHistoND", _wrap_new_Ref_DWSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DWSampleAccNUHistoND_restore", _wrap_Ref_DWSampleAccNUHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DWSampleAccNUHistoND_retrieve", _wrap_Ref_DWSampleAccNUHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DWSampleAccNUHistoND_getValue", _wrap_Ref_DWSampleAccNUHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DWSampleAccNUHistoND", _wrap_delete_Ref_DWSampleAccNUHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DWSampleAccNUHistoND_swigregister", Ref_DWSampleAccNUHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DWSampleAccDAHistoND", _wrap_new_ArchiveRecord_DWSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DWSampleAccDAHistoND", _wrap_delete_ArchiveRecord_DWSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DWSampleAccDAHistoND_swigregister", ArchiveRecord_DWSampleAccDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DWSampleAccDAHistoND", _wrap_new_Ref_DWSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DWSampleAccDAHistoND_restore", _wrap_Ref_DWSampleAccDAHistoND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DWSampleAccDAHistoND_retrieve", _wrap_Ref_DWSampleAccDAHistoND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DWSampleAccDAHistoND_getValue", _wrap_Ref_DWSampleAccDAHistoND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DWSampleAccDAHistoND", _wrap_delete_Ref_DWSampleAccDAHistoND, METH_VARARGS, NULL},
	{ (char *)"Ref_DWSampleAccDAHistoND_swigregister", Ref_DWSampleAccDAHistoND_swigregister, METH_VARARGS, NULL},
	{ (char *)"HistoNDCdf_dim", _wrap_HistoNDCdf_dim, METH_VARARGS, NULL},
	{ (char *)"HistoNDCdf_boundingBox", _wrap_HistoNDCdf_boundingBox, METH_VARARGS, NULL},
	{ (char *)"HistoNDCdf_cdf", _wrap_HistoNDCdf_cdf, METH_VARARGS, NULL},
	{ (char *)"HistoNDCdf_boxCoverage", _wrap_HistoNDCdf_boxCoverage, METH_VARARGS, NULL},
	{ (char *)"HistoNDCdf_coveringBox", _wrap_HistoNDCdf_coveringBox, METH_VARARGS, NULL},
	{ (char *)"new_HistoNDCdf", _wrap_new_HistoNDCdf, METH_VARARGS, NULL},
	{ (char *)"delete_HistoNDCdf", _wrap_delete_HistoNDCdf, METH_VARARGS, NULL},
	{ (char *)"HistoNDCdf_swigregister", HistoNDCdf_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Int0NtHistoFill", _wrap_new_Int0NtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Int0NtHistoFill_callsFillC", _wrap_Int0NtHistoFill_callsFillC, METH_VARARGS, NULL},
	{ (char *)"Int0NtHistoFill_histoClassname", _wrap_Int0NtHistoFill_histoClassname, METH_VARARGS, NULL},
	{ (char *)"delete_Int0NtHistoFill", _wrap_delete_Int0NtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Int0NtHistoFill_swigregister", Int0NtHistoFill_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLong0NtHistoFill", _wrap_new_LLong0NtHistoFill, METH_VARARGS, NULL},
	{ (char *)"LLong0NtHistoFill_callsFillC", _wrap_LLong0NtHistoFill_callsFillC, METH_VARARGS, NULL},
	{ (char *)"LLong0NtHistoFill_histoClassname", _wrap_LLong0NtHistoFill_histoClassname, METH_VARARGS, NULL},
	{ (char *)"delete_LLong0NtHistoFill", _wrap_delete_LLong0NtHistoFill, METH_VARARGS, NULL},
	{ (char *)"LLong0NtHistoFill_swigregister", LLong0NtHistoFill_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Float0NtHistoFill", _wrap_new_Float0NtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Float0NtHistoFill_callsFillC", _wrap_Float0NtHistoFill_callsFillC, METH_VARARGS, NULL},
	{ (char *)"Float0NtHistoFill_histoClassname", _wrap_Float0NtHistoFill_histoClassname, METH_VARARGS, NULL},
	{ (char *)"delete_Float0NtHistoFill", _wrap_delete_Float0NtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Float0NtHistoFill_swigregister", Float0NtHistoFill_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Double0NtHistoFill", _wrap_new_Double0NtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Double0NtHistoFill_callsFillC", _wrap_Double0NtHistoFill_callsFillC, METH_VARARGS, NULL},
	{ (char *)"Double0NtHistoFill_histoClassname", _wrap_Double0NtHistoFill_histoClassname, METH_VARARGS, NULL},
	{ (char *)"delete_Double0NtHistoFill", _wrap_delete_Double0NtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Double0NtHistoFill_swigregister", Double0NtHistoFill_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Int1NtHistoFill", _wrap_new_Int1NtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Int1NtHistoFill_callsFillC", _wrap_Int1NtHistoFill_callsFillC, METH_VARARGS, NULL},
	{ (char *)"Int1NtHistoFill_histoClassname", _wrap_Int1NtHistoFill_histoClassname, METH_VARARGS, NULL},
	{ (char *)"delete_Int1NtHistoFill", _wrap_delete_Int1NtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Int1NtHistoFill_swigregister", Int1NtHistoFill_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLong1NtHistoFill", _wrap_new_LLong1NtHistoFill, METH_VARARGS, NULL},
	{ (char *)"LLong1NtHistoFill_callsFillC", _wrap_LLong1NtHistoFill_callsFillC, METH_VARARGS, NULL},
	{ (char *)"LLong1NtHistoFill_histoClassname", _wrap_LLong1NtHistoFill_histoClassname, METH_VARARGS, NULL},
	{ (char *)"delete_LLong1NtHistoFill", _wrap_delete_LLong1NtHistoFill, METH_VARARGS, NULL},
	{ (char *)"LLong1NtHistoFill_swigregister", LLong1NtHistoFill_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Float1NtHistoFill", _wrap_new_Float1NtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Float1NtHistoFill_callsFillC", _wrap_Float1NtHistoFill_callsFillC, METH_VARARGS, NULL},
	{ (char *)"Float1NtHistoFill_histoClassname", _wrap_Float1NtHistoFill_histoClassname, METH_VARARGS, NULL},
	{ (char *)"delete_Float1NtHistoFill", _wrap_delete_Float1NtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Float1NtHistoFill_swigregister", Float1NtHistoFill_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Double1NtHistoFill", _wrap_new_Double1NtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Double1NtHistoFill_callsFillC", _wrap_Double1NtHistoFill_callsFillC, METH_VARARGS, NULL},
	{ (char *)"Double1NtHistoFill_histoClassname", _wrap_Double1NtHistoFill_histoClassname, METH_VARARGS, NULL},
	{ (char *)"delete_Double1NtHistoFill", _wrap_delete_Double1NtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Double1NtHistoFill_swigregister", Double1NtHistoFill_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Int0NUNtHistoFill", _wrap_new_Int0NUNtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Int0NUNtHistoFill_callsFillC", _wrap_Int0NUNtHistoFill_callsFillC, METH_VARARGS, NULL},
	{ (char *)"Int0NUNtHistoFill_histoClassname", _wrap_Int0NUNtHistoFill_histoClassname, METH_VARARGS, NULL},
	{ (char *)"delete_Int0NUNtHistoFill", _wrap_delete_Int0NUNtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Int0NUNtHistoFill_swigregister", Int0NUNtHistoFill_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLong0NUNtHistoFill", _wrap_new_LLong0NUNtHistoFill, METH_VARARGS, NULL},
	{ (char *)"LLong0NUNtHistoFill_callsFillC", _wrap_LLong0NUNtHistoFill_callsFillC, METH_VARARGS, NULL},
	{ (char *)"LLong0NUNtHistoFill_histoClassname", _wrap_LLong0NUNtHistoFill_histoClassname, METH_VARARGS, NULL},
	{ (char *)"delete_LLong0NUNtHistoFill", _wrap_delete_LLong0NUNtHistoFill, METH_VARARGS, NULL},
	{ (char *)"LLong0NUNtHistoFill_swigregister", LLong0NUNtHistoFill_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Float0NUNtHistoFill", _wrap_new_Float0NUNtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Float0NUNtHistoFill_callsFillC", _wrap_Float0NUNtHistoFill_callsFillC, METH_VARARGS, NULL},
	{ (char *)"Float0NUNtHistoFill_histoClassname", _wrap_Float0NUNtHistoFill_histoClassname, METH_VARARGS, NULL},
	{ (char *)"delete_Float0NUNtHistoFill", _wrap_delete_Float0NUNtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Float0NUNtHistoFill_swigregister", Float0NUNtHistoFill_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Double0NUNtHistoFill", _wrap_new_Double0NUNtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Double0NUNtHistoFill_callsFillC", _wrap_Double0NUNtHistoFill_callsFillC, METH_VARARGS, NULL},
	{ (char *)"Double0NUNtHistoFill_histoClassname", _wrap_Double0NUNtHistoFill_histoClassname, METH_VARARGS, NULL},
	{ (char *)"delete_Double0NUNtHistoFill", _wrap_delete_Double0NUNtHistoFill, METH_VARARGS, NULL},
	{ (char *)"Double0NUNtHistoFill_swigregister", Double0NUNtHistoFill_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntNtNtupleFill", _wrap_new_IntNtNtupleFill, METH_VARARGS, NULL},
	{ (char *)"delete_IntNtNtupleFill", _wrap_delete_IntNtNtupleFill, METH_VARARGS, NULL},
	{ (char *)"IntNtNtupleFill_swigregister", IntNtNtupleFill_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongNtNtupleFill", _wrap_new_LLongNtNtupleFill, METH_VARARGS, NULL},
	{ (char *)"delete_LLongNtNtupleFill", _wrap_delete_LLongNtNtupleFill, METH_VARARGS, NULL},
	{ (char *)"LLongNtNtupleFill_swigregister", LLongNtNtupleFill_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharNtNtupleFill", _wrap_new_UCharNtNtupleFill, METH_VARARGS, NULL},
	{ (char *)"delete_UCharNtNtupleFill", _wrap_delete_UCharNtNtupleFill, METH_VARARGS, NULL},
	{ (char *)"UCharNtNtupleFill_swigregister", UCharNtNtupleFill_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatNtNtupleFill", _wrap_new_FloatNtNtupleFill, METH_VARARGS, NULL},
	{ (char *)"delete_FloatNtNtupleFill", _wrap_delete_FloatNtNtupleFill, METH_VARARGS, NULL},
	{ (char *)"FloatNtNtupleFill_swigregister", FloatNtNtupleFill_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleNtNtupleFill", _wrap_new_DoubleNtNtupleFill, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleNtNtupleFill", _wrap_delete_DoubleNtNtupleFill, METH_VARARGS, NULL},
	{ (char *)"DoubleNtNtupleFill_swigregister", DoubleNtNtupleFill_swigregister, METH_VARARGS, NULL},
	{ (char *)"make_NtNtupleFill", _wrap_make_NtNtupleFill, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut_invert", _wrap_UCharNtRectangularCut_invert, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut_dim", _wrap_UCharNtRectangularCut_dim, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut_cutColumn", _wrap_UCharNtRectangularCut_cutColumn, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut_cutInterval", _wrap_UCharNtRectangularCut_cutInterval, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut_isInverted", _wrap_UCharNtRectangularCut_isInverted, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut_nUniqueColumns", _wrap_UCharNtRectangularCut_nUniqueColumns, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut_ntupleColumns", _wrap_UCharNtRectangularCut_ntupleColumns, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut_acceptedBox", _wrap_UCharNtRectangularCut_acceptedBox, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut___call__", _wrap_UCharNtRectangularCut___call__, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut___eq__", _wrap_UCharNtRectangularCut___eq__, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut___ne__", _wrap_UCharNtRectangularCut___ne__, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut_classId", _wrap_UCharNtRectangularCut_classId, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut_write", _wrap_UCharNtRectangularCut_write, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut_classname", _wrap_UCharNtRectangularCut_classname, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut_version", _wrap_UCharNtRectangularCut_version, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut_restore", _wrap_UCharNtRectangularCut_restore, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut_addCut", _wrap_UCharNtRectangularCut_addCut, METH_VARARGS, NULL},
	{ (char *)"new_UCharNtRectangularCut", _wrap_new_UCharNtRectangularCut, METH_VARARGS, NULL},
	{ (char *)"delete_UCharNtRectangularCut", _wrap_delete_UCharNtRectangularCut, METH_VARARGS, NULL},
	{ (char *)"UCharNtRectangularCut_swigregister", UCharNtRectangularCut_swigregister, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut_invert", _wrap_IntNtRectangularCut_invert, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut_dim", _wrap_IntNtRectangularCut_dim, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut_cutColumn", _wrap_IntNtRectangularCut_cutColumn, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut_cutInterval", _wrap_IntNtRectangularCut_cutInterval, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut_isInverted", _wrap_IntNtRectangularCut_isInverted, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut_nUniqueColumns", _wrap_IntNtRectangularCut_nUniqueColumns, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut_ntupleColumns", _wrap_IntNtRectangularCut_ntupleColumns, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut_acceptedBox", _wrap_IntNtRectangularCut_acceptedBox, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut___call__", _wrap_IntNtRectangularCut___call__, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut___eq__", _wrap_IntNtRectangularCut___eq__, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut___ne__", _wrap_IntNtRectangularCut___ne__, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut_classId", _wrap_IntNtRectangularCut_classId, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut_write", _wrap_IntNtRectangularCut_write, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut_classname", _wrap_IntNtRectangularCut_classname, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut_version", _wrap_IntNtRectangularCut_version, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut_restore", _wrap_IntNtRectangularCut_restore, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut_addCut", _wrap_IntNtRectangularCut_addCut, METH_VARARGS, NULL},
	{ (char *)"new_IntNtRectangularCut", _wrap_new_IntNtRectangularCut, METH_VARARGS, NULL},
	{ (char *)"delete_IntNtRectangularCut", _wrap_delete_IntNtRectangularCut, METH_VARARGS, NULL},
	{ (char *)"IntNtRectangularCut_swigregister", IntNtRectangularCut_swigregister, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut_invert", _wrap_LLongNtRectangularCut_invert, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut_dim", _wrap_LLongNtRectangularCut_dim, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut_cutColumn", _wrap_LLongNtRectangularCut_cutColumn, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut_cutInterval", _wrap_LLongNtRectangularCut_cutInterval, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut_isInverted", _wrap_LLongNtRectangularCut_isInverted, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut_nUniqueColumns", _wrap_LLongNtRectangularCut_nUniqueColumns, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut_ntupleColumns", _wrap_LLongNtRectangularCut_ntupleColumns, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut_acceptedBox", _wrap_LLongNtRectangularCut_acceptedBox, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut___call__", _wrap_LLongNtRectangularCut___call__, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut___eq__", _wrap_LLongNtRectangularCut___eq__, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut___ne__", _wrap_LLongNtRectangularCut___ne__, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut_classId", _wrap_LLongNtRectangularCut_classId, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut_write", _wrap_LLongNtRectangularCut_write, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut_classname", _wrap_LLongNtRectangularCut_classname, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut_version", _wrap_LLongNtRectangularCut_version, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut_restore", _wrap_LLongNtRectangularCut_restore, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut_addCut", _wrap_LLongNtRectangularCut_addCut, METH_VARARGS, NULL},
	{ (char *)"new_LLongNtRectangularCut", _wrap_new_LLongNtRectangularCut, METH_VARARGS, NULL},
	{ (char *)"delete_LLongNtRectangularCut", _wrap_delete_LLongNtRectangularCut, METH_VARARGS, NULL},
	{ (char *)"LLongNtRectangularCut_swigregister", LLongNtRectangularCut_swigregister, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut_invert", _wrap_FloatNtRectangularCut_invert, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut_dim", _wrap_FloatNtRectangularCut_dim, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut_cutColumn", _wrap_FloatNtRectangularCut_cutColumn, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut_cutInterval", _wrap_FloatNtRectangularCut_cutInterval, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut_isInverted", _wrap_FloatNtRectangularCut_isInverted, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut_nUniqueColumns", _wrap_FloatNtRectangularCut_nUniqueColumns, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut_ntupleColumns", _wrap_FloatNtRectangularCut_ntupleColumns, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut_acceptedBox", _wrap_FloatNtRectangularCut_acceptedBox, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut___call__", _wrap_FloatNtRectangularCut___call__, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut___eq__", _wrap_FloatNtRectangularCut___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut___ne__", _wrap_FloatNtRectangularCut___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut_classId", _wrap_FloatNtRectangularCut_classId, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut_write", _wrap_FloatNtRectangularCut_write, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut_classname", _wrap_FloatNtRectangularCut_classname, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut_version", _wrap_FloatNtRectangularCut_version, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut_restore", _wrap_FloatNtRectangularCut_restore, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut_addCut", _wrap_FloatNtRectangularCut_addCut, METH_VARARGS, NULL},
	{ (char *)"new_FloatNtRectangularCut", _wrap_new_FloatNtRectangularCut, METH_VARARGS, NULL},
	{ (char *)"delete_FloatNtRectangularCut", _wrap_delete_FloatNtRectangularCut, METH_VARARGS, NULL},
	{ (char *)"FloatNtRectangularCut_swigregister", FloatNtRectangularCut_swigregister, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut_invert", _wrap_DoubleNtRectangularCut_invert, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut_dim", _wrap_DoubleNtRectangularCut_dim, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut_cutColumn", _wrap_DoubleNtRectangularCut_cutColumn, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut_cutInterval", _wrap_DoubleNtRectangularCut_cutInterval, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut_isInverted", _wrap_DoubleNtRectangularCut_isInverted, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut_nUniqueColumns", _wrap_DoubleNtRectangularCut_nUniqueColumns, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut_ntupleColumns", _wrap_DoubleNtRectangularCut_ntupleColumns, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut_acceptedBox", _wrap_DoubleNtRectangularCut_acceptedBox, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut___call__", _wrap_DoubleNtRectangularCut___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut___eq__", _wrap_DoubleNtRectangularCut___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut___ne__", _wrap_DoubleNtRectangularCut___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut_classId", _wrap_DoubleNtRectangularCut_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut_write", _wrap_DoubleNtRectangularCut_write, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut_classname", _wrap_DoubleNtRectangularCut_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut_version", _wrap_DoubleNtRectangularCut_version, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut_restore", _wrap_DoubleNtRectangularCut_restore, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut_addCut", _wrap_DoubleNtRectangularCut_addCut, METH_VARARGS, NULL},
	{ (char *)"new_DoubleNtRectangularCut", _wrap_new_DoubleNtRectangularCut, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleNtRectangularCut", _wrap_delete_DoubleNtRectangularCut, METH_VARARGS, NULL},
	{ (char *)"DoubleNtRectangularCut_swigregister", DoubleNtRectangularCut_swigregister, METH_VARARGS, NULL},
	{ (char *)"ntupleColumns", _wrap_ntupleColumns, METH_VARARGS, NULL},
	{ (char *)"simpleColumnNames", _wrap_simpleColumnNames, METH_VARARGS, NULL},
	{ (char *)"delete_UCharAbsNtuple", _wrap_delete_UCharAbsNtuple, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_title", _wrap_UCharAbsNtuple_title, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_setTitle", _wrap_UCharAbsNtuple_setTitle, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_nColumns", _wrap_UCharAbsNtuple_nColumns, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_columnName", _wrap_UCharAbsNtuple_columnName, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_columnNames", _wrap_UCharAbsNtuple_columnNames, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_setColumnName", _wrap_UCharAbsNtuple_setColumnName, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_columnNumber", _wrap_UCharAbsNtuple_columnNumber, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_validColumn", _wrap_UCharAbsNtuple_validColumn, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_nRows", _wrap_UCharAbsNtuple_nRows, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_length", _wrap_UCharAbsNtuple_length, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_fill", _wrap_UCharAbsNtuple_fill, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple___call__", _wrap_UCharAbsNtuple___call__, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_at", _wrap_UCharAbsNtuple_at, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_element", _wrap_UCharAbsNtuple_element, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_elementAt", _wrap_UCharAbsNtuple_elementAt, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_rowContents", _wrap_UCharAbsNtuple_rowContents, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_columnContents", _wrap_UCharAbsNtuple_columnContents, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_clear", _wrap_UCharAbsNtuple_clear, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_row_begin", _wrap_UCharAbsNtuple_row_begin, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_row_end", _wrap_UCharAbsNtuple_row_end, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_column_begin", _wrap_UCharAbsNtuple_column_begin, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_column_end", _wrap_UCharAbsNtuple_column_end, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_columnIndices", _wrap_UCharAbsNtuple_columnIndices, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_classId", _wrap_UCharAbsNtuple_classId, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple___eq__", _wrap_UCharAbsNtuple___eq__, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple___ne__", _wrap_UCharAbsNtuple___ne__, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_append", _wrap_UCharAbsNtuple_append, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_columnArray", _wrap_UCharAbsNtuple_columnArray, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_rowArray", _wrap_UCharAbsNtuple_rowArray, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_cycleOverRows", _wrap_UCharAbsNtuple_cycleOverRows, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_cutCycleOverRows", _wrap_UCharAbsNtuple_cutCycleOverRows, METH_VARARGS, NULL},
	{ (char *)"UCharAbsNtuple_swigregister", UCharAbsNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_IntAbsNtuple", _wrap_delete_IntAbsNtuple, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_title", _wrap_IntAbsNtuple_title, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_setTitle", _wrap_IntAbsNtuple_setTitle, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_nColumns", _wrap_IntAbsNtuple_nColumns, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_columnName", _wrap_IntAbsNtuple_columnName, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_columnNames", _wrap_IntAbsNtuple_columnNames, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_setColumnName", _wrap_IntAbsNtuple_setColumnName, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_columnNumber", _wrap_IntAbsNtuple_columnNumber, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_validColumn", _wrap_IntAbsNtuple_validColumn, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_nRows", _wrap_IntAbsNtuple_nRows, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_length", _wrap_IntAbsNtuple_length, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_fill", _wrap_IntAbsNtuple_fill, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple___call__", _wrap_IntAbsNtuple___call__, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_at", _wrap_IntAbsNtuple_at, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_element", _wrap_IntAbsNtuple_element, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_elementAt", _wrap_IntAbsNtuple_elementAt, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_rowContents", _wrap_IntAbsNtuple_rowContents, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_columnContents", _wrap_IntAbsNtuple_columnContents, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_clear", _wrap_IntAbsNtuple_clear, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_row_begin", _wrap_IntAbsNtuple_row_begin, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_row_end", _wrap_IntAbsNtuple_row_end, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_column_begin", _wrap_IntAbsNtuple_column_begin, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_column_end", _wrap_IntAbsNtuple_column_end, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_columnIndices", _wrap_IntAbsNtuple_columnIndices, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_classId", _wrap_IntAbsNtuple_classId, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple___eq__", _wrap_IntAbsNtuple___eq__, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple___ne__", _wrap_IntAbsNtuple___ne__, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_append", _wrap_IntAbsNtuple_append, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_columnArray", _wrap_IntAbsNtuple_columnArray, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_rowArray", _wrap_IntAbsNtuple_rowArray, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_cycleOverRows", _wrap_IntAbsNtuple_cycleOverRows, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_cutCycleOverRows", _wrap_IntAbsNtuple_cutCycleOverRows, METH_VARARGS, NULL},
	{ (char *)"IntAbsNtuple_swigregister", IntAbsNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_LLongAbsNtuple", _wrap_delete_LLongAbsNtuple, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_title", _wrap_LLongAbsNtuple_title, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_setTitle", _wrap_LLongAbsNtuple_setTitle, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_nColumns", _wrap_LLongAbsNtuple_nColumns, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_columnName", _wrap_LLongAbsNtuple_columnName, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_columnNames", _wrap_LLongAbsNtuple_columnNames, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_setColumnName", _wrap_LLongAbsNtuple_setColumnName, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_columnNumber", _wrap_LLongAbsNtuple_columnNumber, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_validColumn", _wrap_LLongAbsNtuple_validColumn, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_nRows", _wrap_LLongAbsNtuple_nRows, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_length", _wrap_LLongAbsNtuple_length, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_fill", _wrap_LLongAbsNtuple_fill, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple___call__", _wrap_LLongAbsNtuple___call__, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_at", _wrap_LLongAbsNtuple_at, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_element", _wrap_LLongAbsNtuple_element, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_elementAt", _wrap_LLongAbsNtuple_elementAt, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_rowContents", _wrap_LLongAbsNtuple_rowContents, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_columnContents", _wrap_LLongAbsNtuple_columnContents, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_clear", _wrap_LLongAbsNtuple_clear, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_row_begin", _wrap_LLongAbsNtuple_row_begin, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_row_end", _wrap_LLongAbsNtuple_row_end, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_column_begin", _wrap_LLongAbsNtuple_column_begin, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_column_end", _wrap_LLongAbsNtuple_column_end, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_columnIndices", _wrap_LLongAbsNtuple_columnIndices, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_classId", _wrap_LLongAbsNtuple_classId, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple___eq__", _wrap_LLongAbsNtuple___eq__, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple___ne__", _wrap_LLongAbsNtuple___ne__, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_append", _wrap_LLongAbsNtuple_append, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_columnArray", _wrap_LLongAbsNtuple_columnArray, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_rowArray", _wrap_LLongAbsNtuple_rowArray, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_cycleOverRows", _wrap_LLongAbsNtuple_cycleOverRows, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_cutCycleOverRows", _wrap_LLongAbsNtuple_cutCycleOverRows, METH_VARARGS, NULL},
	{ (char *)"LLongAbsNtuple_swigregister", LLongAbsNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_FloatAbsNtuple", _wrap_delete_FloatAbsNtuple, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_title", _wrap_FloatAbsNtuple_title, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_setTitle", _wrap_FloatAbsNtuple_setTitle, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_nColumns", _wrap_FloatAbsNtuple_nColumns, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_columnName", _wrap_FloatAbsNtuple_columnName, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_columnNames", _wrap_FloatAbsNtuple_columnNames, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_setColumnName", _wrap_FloatAbsNtuple_setColumnName, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_columnNumber", _wrap_FloatAbsNtuple_columnNumber, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_validColumn", _wrap_FloatAbsNtuple_validColumn, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_nRows", _wrap_FloatAbsNtuple_nRows, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_length", _wrap_FloatAbsNtuple_length, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_fill", _wrap_FloatAbsNtuple_fill, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple___call__", _wrap_FloatAbsNtuple___call__, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_at", _wrap_FloatAbsNtuple_at, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_element", _wrap_FloatAbsNtuple_element, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_elementAt", _wrap_FloatAbsNtuple_elementAt, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_rowContents", _wrap_FloatAbsNtuple_rowContents, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_columnContents", _wrap_FloatAbsNtuple_columnContents, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_clear", _wrap_FloatAbsNtuple_clear, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_row_begin", _wrap_FloatAbsNtuple_row_begin, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_row_end", _wrap_FloatAbsNtuple_row_end, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_column_begin", _wrap_FloatAbsNtuple_column_begin, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_column_end", _wrap_FloatAbsNtuple_column_end, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_columnIndices", _wrap_FloatAbsNtuple_columnIndices, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_classId", _wrap_FloatAbsNtuple_classId, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple___eq__", _wrap_FloatAbsNtuple___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple___ne__", _wrap_FloatAbsNtuple___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_append", _wrap_FloatAbsNtuple_append, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_columnArray", _wrap_FloatAbsNtuple_columnArray, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_rowArray", _wrap_FloatAbsNtuple_rowArray, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_cycleOverRows", _wrap_FloatAbsNtuple_cycleOverRows, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_cutCycleOverRows", _wrap_FloatAbsNtuple_cutCycleOverRows, METH_VARARGS, NULL},
	{ (char *)"FloatAbsNtuple_swigregister", FloatAbsNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleAbsNtuple", _wrap_delete_DoubleAbsNtuple, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_title", _wrap_DoubleAbsNtuple_title, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_setTitle", _wrap_DoubleAbsNtuple_setTitle, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_nColumns", _wrap_DoubleAbsNtuple_nColumns, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_columnName", _wrap_DoubleAbsNtuple_columnName, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_columnNames", _wrap_DoubleAbsNtuple_columnNames, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_setColumnName", _wrap_DoubleAbsNtuple_setColumnName, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_columnNumber", _wrap_DoubleAbsNtuple_columnNumber, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_validColumn", _wrap_DoubleAbsNtuple_validColumn, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_nRows", _wrap_DoubleAbsNtuple_nRows, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_length", _wrap_DoubleAbsNtuple_length, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_fill", _wrap_DoubleAbsNtuple_fill, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple___call__", _wrap_DoubleAbsNtuple___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_at", _wrap_DoubleAbsNtuple_at, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_element", _wrap_DoubleAbsNtuple_element, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_elementAt", _wrap_DoubleAbsNtuple_elementAt, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_rowContents", _wrap_DoubleAbsNtuple_rowContents, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_columnContents", _wrap_DoubleAbsNtuple_columnContents, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_clear", _wrap_DoubleAbsNtuple_clear, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_row_begin", _wrap_DoubleAbsNtuple_row_begin, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_row_end", _wrap_DoubleAbsNtuple_row_end, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_column_begin", _wrap_DoubleAbsNtuple_column_begin, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_column_end", _wrap_DoubleAbsNtuple_column_end, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_columnIndices", _wrap_DoubleAbsNtuple_columnIndices, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_classId", _wrap_DoubleAbsNtuple_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple___eq__", _wrap_DoubleAbsNtuple___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple___ne__", _wrap_DoubleAbsNtuple___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_append", _wrap_DoubleAbsNtuple_append, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_columnArray", _wrap_DoubleAbsNtuple_columnArray, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_rowArray", _wrap_DoubleAbsNtuple_rowArray, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_cycleOverRows", _wrap_DoubleAbsNtuple_cycleOverRows, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_cutCycleOverRows", _wrap_DoubleAbsNtuple_cutCycleOverRows, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsNtuple_swigregister", DoubleAbsNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"dumpNtupleAsText", _wrap_dumpNtupleAsText, METH_VARARGS, NULL},
	{ (char *)"fillNtupleFromText", _wrap_fillNtupleFromText, METH_VARARGS, NULL},
	{ (char *)"new_ItemLocation", _wrap_new_ItemLocation, METH_VARARGS, NULL},
	{ (char *)"ItemLocation_URI", _wrap_ItemLocation_URI, METH_VARARGS, NULL},
	{ (char *)"ItemLocation_cachedItemURI", _wrap_ItemLocation_cachedItemURI, METH_VARARGS, NULL},
	{ (char *)"ItemLocation_setURI", _wrap_ItemLocation_setURI, METH_VARARGS, NULL},
	{ (char *)"ItemLocation_setCachedItemURI", _wrap_ItemLocation_setCachedItemURI, METH_VARARGS, NULL},
	{ (char *)"ItemLocation___eq__", _wrap_ItemLocation___eq__, METH_VARARGS, NULL},
	{ (char *)"ItemLocation___ne__", _wrap_ItemLocation___ne__, METH_VARARGS, NULL},
	{ (char *)"ItemLocation_classId", _wrap_ItemLocation_classId, METH_VARARGS, NULL},
	{ (char *)"ItemLocation_write", _wrap_ItemLocation_write, METH_VARARGS, NULL},
	{ (char *)"ItemLocation_classname", _wrap_ItemLocation_classname, METH_VARARGS, NULL},
	{ (char *)"ItemLocation_version", _wrap_ItemLocation_version, METH_VARARGS, NULL},
	{ (char *)"ItemLocation_read", _wrap_ItemLocation_read, METH_VARARGS, NULL},
	{ (char *)"ItemLocation_streamPos", _wrap_ItemLocation_streamPos, METH_VARARGS, NULL},
	{ (char *)"ItemLocation_setStreamPos", _wrap_ItemLocation_setStreamPos, METH_VARARGS, NULL},
	{ (char *)"delete_ItemLocation", _wrap_delete_ItemLocation, METH_VARARGS, NULL},
	{ (char *)"ItemLocation_swigregister", ItemLocation_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_CatalogEntry", _wrap_new_CatalogEntry, METH_VARARGS, NULL},
	{ (char *)"delete_CatalogEntry", _wrap_delete_CatalogEntry, METH_VARARGS, NULL},
	{ (char *)"CatalogEntry_id", _wrap_CatalogEntry_id, METH_VARARGS, NULL},
	{ (char *)"CatalogEntry_offset", _wrap_CatalogEntry_offset, METH_VARARGS, NULL},
	{ (char *)"CatalogEntry_location", _wrap_CatalogEntry_location, METH_VARARGS, NULL},
	{ (char *)"CatalogEntry_itemLength", _wrap_CatalogEntry_itemLength, METH_VARARGS, NULL},
	{ (char *)"CatalogEntry_compressionCode", _wrap_CatalogEntry_compressionCode, METH_VARARGS, NULL},
	{ (char *)"CatalogEntry_setStreamPosition", _wrap_CatalogEntry_setStreamPosition, METH_VARARGS, NULL},
	{ (char *)"CatalogEntry_setURI", _wrap_CatalogEntry_setURI, METH_VARARGS, NULL},
	{ (char *)"CatalogEntry_setCachedItemURI", _wrap_CatalogEntry_setCachedItemURI, METH_VARARGS, NULL},
	{ (char *)"CatalogEntry_setOffset", _wrap_CatalogEntry_setOffset, METH_VARARGS, NULL},
	{ (char *)"CatalogEntry_humanReadable", _wrap_CatalogEntry_humanReadable, METH_VARARGS, NULL},
	{ (char *)"CatalogEntry_classId", _wrap_CatalogEntry_classId, METH_VARARGS, NULL},
	{ (char *)"CatalogEntry_write", _wrap_CatalogEntry_write, METH_VARARGS, NULL},
	{ (char *)"CatalogEntry_classname", _wrap_CatalogEntry_classname, METH_VARARGS, NULL},
	{ (char *)"CatalogEntry_version", _wrap_CatalogEntry_version, METH_VARARGS, NULL},
	{ (char *)"CatalogEntry_read", _wrap_CatalogEntry_read, METH_VARARGS, NULL},
	{ (char *)"CatalogEntry_swigregister", CatalogEntry_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsArchive", _wrap_delete_AbsArchive, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_name", _wrap_AbsArchive_name, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_isOpen", _wrap_AbsArchive_isOpen, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_error", _wrap_AbsArchive_error, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_isReadable", _wrap_AbsArchive_isReadable, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_isWritable", _wrap_AbsArchive_isWritable, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_size", _wrap_AbsArchive_size, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_smallestId", _wrap_AbsArchive_smallestId, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_largestId", _wrap_AbsArchive_largestId, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_idsAreContiguous", _wrap_AbsArchive_idsAreContiguous, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_itemExists", _wrap_AbsArchive_itemExists, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_itemSearch", _wrap_AbsArchive_itemSearch, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_flush", _wrap_AbsArchive_flush, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_copyItem", _wrap_AbsArchive_copyItem, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_lastItemId", _wrap_AbsArchive_lastItemId, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_lastItemLength", _wrap_AbsArchive_lastItemLength, METH_VARARGS, NULL},
	{ (char *)"AbsArchive___eq__", _wrap_AbsArchive___eq__, METH_VARARGS, NULL},
	{ (char *)"AbsArchive___ne__", _wrap_AbsArchive___ne__, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_categories", _wrap_AbsArchive_categories, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_store", _wrap_AbsArchive_store, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_findItems", _wrap_AbsArchive_findItems, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_getCatalogEntry", _wrap_AbsArchive_getCatalogEntry, METH_VARARGS, NULL},
	{ (char *)"AbsArchive_swigregister", AbsArchive_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharArchivedNtuple", _wrap_new_UCharArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_UCharArchivedNtuple", _wrap_delete_UCharArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_archive", _wrap_UCharArchivedNtuple_archive, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_name", _wrap_UCharArchivedNtuple_name, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_category", _wrap_UCharArchivedNtuple_category, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_rowsPerBuffer", _wrap_UCharArchivedNtuple_rowsPerBuffer, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_writesByColumn", _wrap_UCharArchivedNtuple_writesByColumn, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_isReadable", _wrap_UCharArchivedNtuple_isReadable, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_isWritable", _wrap_UCharArchivedNtuple_isWritable, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_objectNumber", _wrap_UCharArchivedNtuple_objectNumber, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_fill", _wrap_UCharArchivedNtuple_fill, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_nRows", _wrap_UCharArchivedNtuple_nRows, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple___call__", _wrap_UCharArchivedNtuple___call__, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_at", _wrap_UCharArchivedNtuple_at, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_rowContents", _wrap_UCharArchivedNtuple_rowContents, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_columnContents", _wrap_UCharArchivedNtuple_columnContents, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_clear", _wrap_UCharArchivedNtuple_clear, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_write", _wrap_UCharArchivedNtuple_write, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_classId", _wrap_UCharArchivedNtuple_classId, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_classname", _wrap_UCharArchivedNtuple_classname, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_version", _wrap_UCharArchivedNtuple_version, METH_VARARGS, NULL},
	{ (char *)"UCharArchivedNtuple_swigregister", UCharArchivedNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntArchivedNtuple", _wrap_new_IntArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_IntArchivedNtuple", _wrap_delete_IntArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_archive", _wrap_IntArchivedNtuple_archive, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_name", _wrap_IntArchivedNtuple_name, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_category", _wrap_IntArchivedNtuple_category, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_rowsPerBuffer", _wrap_IntArchivedNtuple_rowsPerBuffer, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_writesByColumn", _wrap_IntArchivedNtuple_writesByColumn, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_isReadable", _wrap_IntArchivedNtuple_isReadable, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_isWritable", _wrap_IntArchivedNtuple_isWritable, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_objectNumber", _wrap_IntArchivedNtuple_objectNumber, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_fill", _wrap_IntArchivedNtuple_fill, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_nRows", _wrap_IntArchivedNtuple_nRows, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple___call__", _wrap_IntArchivedNtuple___call__, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_at", _wrap_IntArchivedNtuple_at, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_rowContents", _wrap_IntArchivedNtuple_rowContents, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_columnContents", _wrap_IntArchivedNtuple_columnContents, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_clear", _wrap_IntArchivedNtuple_clear, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_write", _wrap_IntArchivedNtuple_write, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_classId", _wrap_IntArchivedNtuple_classId, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_classname", _wrap_IntArchivedNtuple_classname, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_version", _wrap_IntArchivedNtuple_version, METH_VARARGS, NULL},
	{ (char *)"IntArchivedNtuple_swigregister", IntArchivedNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongArchivedNtuple", _wrap_new_LLongArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_LLongArchivedNtuple", _wrap_delete_LLongArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_archive", _wrap_LLongArchivedNtuple_archive, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_name", _wrap_LLongArchivedNtuple_name, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_category", _wrap_LLongArchivedNtuple_category, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_rowsPerBuffer", _wrap_LLongArchivedNtuple_rowsPerBuffer, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_writesByColumn", _wrap_LLongArchivedNtuple_writesByColumn, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_isReadable", _wrap_LLongArchivedNtuple_isReadable, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_isWritable", _wrap_LLongArchivedNtuple_isWritable, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_objectNumber", _wrap_LLongArchivedNtuple_objectNumber, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_fill", _wrap_LLongArchivedNtuple_fill, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_nRows", _wrap_LLongArchivedNtuple_nRows, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple___call__", _wrap_LLongArchivedNtuple___call__, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_at", _wrap_LLongArchivedNtuple_at, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_rowContents", _wrap_LLongArchivedNtuple_rowContents, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_columnContents", _wrap_LLongArchivedNtuple_columnContents, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_clear", _wrap_LLongArchivedNtuple_clear, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_write", _wrap_LLongArchivedNtuple_write, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_classId", _wrap_LLongArchivedNtuple_classId, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_classname", _wrap_LLongArchivedNtuple_classname, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_version", _wrap_LLongArchivedNtuple_version, METH_VARARGS, NULL},
	{ (char *)"LLongArchivedNtuple_swigregister", LLongArchivedNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatArchivedNtuple", _wrap_new_FloatArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_FloatArchivedNtuple", _wrap_delete_FloatArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_archive", _wrap_FloatArchivedNtuple_archive, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_name", _wrap_FloatArchivedNtuple_name, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_category", _wrap_FloatArchivedNtuple_category, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_rowsPerBuffer", _wrap_FloatArchivedNtuple_rowsPerBuffer, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_writesByColumn", _wrap_FloatArchivedNtuple_writesByColumn, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_isReadable", _wrap_FloatArchivedNtuple_isReadable, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_isWritable", _wrap_FloatArchivedNtuple_isWritable, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_objectNumber", _wrap_FloatArchivedNtuple_objectNumber, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_fill", _wrap_FloatArchivedNtuple_fill, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_nRows", _wrap_FloatArchivedNtuple_nRows, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple___call__", _wrap_FloatArchivedNtuple___call__, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_at", _wrap_FloatArchivedNtuple_at, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_rowContents", _wrap_FloatArchivedNtuple_rowContents, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_columnContents", _wrap_FloatArchivedNtuple_columnContents, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_clear", _wrap_FloatArchivedNtuple_clear, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_write", _wrap_FloatArchivedNtuple_write, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_classId", _wrap_FloatArchivedNtuple_classId, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_classname", _wrap_FloatArchivedNtuple_classname, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_version", _wrap_FloatArchivedNtuple_version, METH_VARARGS, NULL},
	{ (char *)"FloatArchivedNtuple_swigregister", FloatArchivedNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleArchivedNtuple", _wrap_new_DoubleArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleArchivedNtuple", _wrap_delete_DoubleArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_archive", _wrap_DoubleArchivedNtuple_archive, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_name", _wrap_DoubleArchivedNtuple_name, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_category", _wrap_DoubleArchivedNtuple_category, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_rowsPerBuffer", _wrap_DoubleArchivedNtuple_rowsPerBuffer, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_writesByColumn", _wrap_DoubleArchivedNtuple_writesByColumn, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_isReadable", _wrap_DoubleArchivedNtuple_isReadable, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_isWritable", _wrap_DoubleArchivedNtuple_isWritable, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_objectNumber", _wrap_DoubleArchivedNtuple_objectNumber, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_fill", _wrap_DoubleArchivedNtuple_fill, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_nRows", _wrap_DoubleArchivedNtuple_nRows, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple___call__", _wrap_DoubleArchivedNtuple___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_at", _wrap_DoubleArchivedNtuple_at, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_rowContents", _wrap_DoubleArchivedNtuple_rowContents, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_columnContents", _wrap_DoubleArchivedNtuple_columnContents, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_clear", _wrap_DoubleArchivedNtuple_clear, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_write", _wrap_DoubleArchivedNtuple_write, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_classId", _wrap_DoubleArchivedNtuple_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_classname", _wrap_DoubleArchivedNtuple_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_version", _wrap_DoubleArchivedNtuple_version, METH_VARARGS, NULL},
	{ (char *)"DoubleArchivedNtuple_swigregister", DoubleArchivedNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsPolyFilter1D", _wrap_delete_AbsPolyFilter1D, METH_VARARGS, NULL},
	{ (char *)"AbsPolyFilter1D_dataLen", _wrap_AbsPolyFilter1D_dataLen, METH_VARARGS, NULL},
	{ (char *)"AbsPolyFilter1D_selfContribution", _wrap_AbsPolyFilter1D_selfContribution, METH_VARARGS, NULL},
	{ (char *)"AbsPolyFilter1D_swigregister", AbsPolyFilter1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_UCharFunctor0", _wrap_delete_UCharFunctor0, METH_VARARGS, NULL},
	{ (char *)"UCharFunctor0___call__", _wrap_UCharFunctor0___call__, METH_VARARGS, NULL},
	{ (char *)"UCharFunctor0_swigregister", UCharFunctor0_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_IntFunctor0", _wrap_delete_IntFunctor0, METH_VARARGS, NULL},
	{ (char *)"IntFunctor0___call__", _wrap_IntFunctor0___call__, METH_VARARGS, NULL},
	{ (char *)"IntFunctor0_swigregister", IntFunctor0_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_LLongFunctor0", _wrap_delete_LLongFunctor0, METH_VARARGS, NULL},
	{ (char *)"LLongFunctor0___call__", _wrap_LLongFunctor0___call__, METH_VARARGS, NULL},
	{ (char *)"LLongFunctor0_swigregister", LLongFunctor0_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_FloatFunctor0", _wrap_delete_FloatFunctor0, METH_VARARGS, NULL},
	{ (char *)"FloatFunctor0___call__", _wrap_FloatFunctor0___call__, METH_VARARGS, NULL},
	{ (char *)"FloatFunctor0_swigregister", FloatFunctor0_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleFunctor0", _wrap_delete_DoubleFunctor0, METH_VARARGS, NULL},
	{ (char *)"DoubleFunctor0___call__", _wrap_DoubleFunctor0___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleFunctor0_swigregister", DoubleFunctor0_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharFcnFunctor0", _wrap_new_UCharFcnFunctor0, METH_VARARGS, NULL},
	{ (char *)"delete_UCharFcnFunctor0", _wrap_delete_UCharFcnFunctor0, METH_VARARGS, NULL},
	{ (char *)"UCharFcnFunctor0___call__", _wrap_UCharFcnFunctor0___call__, METH_VARARGS, NULL},
	{ (char *)"UCharFcnFunctor0___eq__", _wrap_UCharFcnFunctor0___eq__, METH_VARARGS, NULL},
	{ (char *)"UCharFcnFunctor0___ne__", _wrap_UCharFcnFunctor0___ne__, METH_VARARGS, NULL},
	{ (char *)"UCharFcnFunctor0_swigregister", UCharFcnFunctor0_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntFcnFunctor0", _wrap_new_IntFcnFunctor0, METH_VARARGS, NULL},
	{ (char *)"delete_IntFcnFunctor0", _wrap_delete_IntFcnFunctor0, METH_VARARGS, NULL},
	{ (char *)"IntFcnFunctor0___call__", _wrap_IntFcnFunctor0___call__, METH_VARARGS, NULL},
	{ (char *)"IntFcnFunctor0___eq__", _wrap_IntFcnFunctor0___eq__, METH_VARARGS, NULL},
	{ (char *)"IntFcnFunctor0___ne__", _wrap_IntFcnFunctor0___ne__, METH_VARARGS, NULL},
	{ (char *)"IntFcnFunctor0_swigregister", IntFcnFunctor0_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongFcnFunctor0", _wrap_new_LLongFcnFunctor0, METH_VARARGS, NULL},
	{ (char *)"delete_LLongFcnFunctor0", _wrap_delete_LLongFcnFunctor0, METH_VARARGS, NULL},
	{ (char *)"LLongFcnFunctor0___call__", _wrap_LLongFcnFunctor0___call__, METH_VARARGS, NULL},
	{ (char *)"LLongFcnFunctor0___eq__", _wrap_LLongFcnFunctor0___eq__, METH_VARARGS, NULL},
	{ (char *)"LLongFcnFunctor0___ne__", _wrap_LLongFcnFunctor0___ne__, METH_VARARGS, NULL},
	{ (char *)"LLongFcnFunctor0_swigregister", LLongFcnFunctor0_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatFcnFunctor0", _wrap_new_FloatFcnFunctor0, METH_VARARGS, NULL},
	{ (char *)"delete_FloatFcnFunctor0", _wrap_delete_FloatFcnFunctor0, METH_VARARGS, NULL},
	{ (char *)"FloatFcnFunctor0___call__", _wrap_FloatFcnFunctor0___call__, METH_VARARGS, NULL},
	{ (char *)"FloatFcnFunctor0___eq__", _wrap_FloatFcnFunctor0___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatFcnFunctor0___ne__", _wrap_FloatFcnFunctor0___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatFcnFunctor0_swigregister", FloatFcnFunctor0_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleFcnFunctor0", _wrap_new_DoubleFcnFunctor0, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleFcnFunctor0", _wrap_delete_DoubleFcnFunctor0, METH_VARARGS, NULL},
	{ (char *)"DoubleFcnFunctor0___call__", _wrap_DoubleFcnFunctor0___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleFcnFunctor0___eq__", _wrap_DoubleFcnFunctor0___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleFcnFunctor0___ne__", _wrap_DoubleFcnFunctor0___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleFcnFunctor0_swigregister", DoubleFcnFunctor0_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_UCharUCharFunctor1", _wrap_delete_UCharUCharFunctor1, METH_VARARGS, NULL},
	{ (char *)"UCharUCharFunctor1___call__", _wrap_UCharUCharFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"UCharUCharFunctor1_swigregister", UCharUCharFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_UCharIntFunctor1", _wrap_delete_UCharIntFunctor1, METH_VARARGS, NULL},
	{ (char *)"UCharIntFunctor1___call__", _wrap_UCharIntFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"UCharIntFunctor1_swigregister", UCharIntFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_UCharLLongFunctor1", _wrap_delete_UCharLLongFunctor1, METH_VARARGS, NULL},
	{ (char *)"UCharLLongFunctor1___call__", _wrap_UCharLLongFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"UCharLLongFunctor1_swigregister", UCharLLongFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_UCharFloatFunctor1", _wrap_delete_UCharFloatFunctor1, METH_VARARGS, NULL},
	{ (char *)"UCharFloatFunctor1___call__", _wrap_UCharFloatFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"UCharFloatFunctor1_swigregister", UCharFloatFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_UCharDoubleFunctor1", _wrap_delete_UCharDoubleFunctor1, METH_VARARGS, NULL},
	{ (char *)"UCharDoubleFunctor1___call__", _wrap_UCharDoubleFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"UCharDoubleFunctor1_swigregister", UCharDoubleFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_IntUCharFunctor1", _wrap_delete_IntUCharFunctor1, METH_VARARGS, NULL},
	{ (char *)"IntUCharFunctor1___call__", _wrap_IntUCharFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"IntUCharFunctor1_swigregister", IntUCharFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_IntIntFunctor1", _wrap_delete_IntIntFunctor1, METH_VARARGS, NULL},
	{ (char *)"IntIntFunctor1___call__", _wrap_IntIntFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"IntIntFunctor1_swigregister", IntIntFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_IntLLongFunctor1", _wrap_delete_IntLLongFunctor1, METH_VARARGS, NULL},
	{ (char *)"IntLLongFunctor1___call__", _wrap_IntLLongFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"IntLLongFunctor1_swigregister", IntLLongFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_IntFloatFunctor1", _wrap_delete_IntFloatFunctor1, METH_VARARGS, NULL},
	{ (char *)"IntFloatFunctor1___call__", _wrap_IntFloatFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"IntFloatFunctor1_swigregister", IntFloatFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_IntDoubleFunctor1", _wrap_delete_IntDoubleFunctor1, METH_VARARGS, NULL},
	{ (char *)"IntDoubleFunctor1___call__", _wrap_IntDoubleFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"IntDoubleFunctor1_swigregister", IntDoubleFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_LLongUCharFunctor1", _wrap_delete_LLongUCharFunctor1, METH_VARARGS, NULL},
	{ (char *)"LLongUCharFunctor1___call__", _wrap_LLongUCharFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"LLongUCharFunctor1_swigregister", LLongUCharFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_LLongIntFunctor1", _wrap_delete_LLongIntFunctor1, METH_VARARGS, NULL},
	{ (char *)"LLongIntFunctor1___call__", _wrap_LLongIntFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"LLongIntFunctor1_swigregister", LLongIntFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_LLongLLongFunctor1", _wrap_delete_LLongLLongFunctor1, METH_VARARGS, NULL},
	{ (char *)"LLongLLongFunctor1___call__", _wrap_LLongLLongFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"LLongLLongFunctor1_swigregister", LLongLLongFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_LLongFloatFunctor1", _wrap_delete_LLongFloatFunctor1, METH_VARARGS, NULL},
	{ (char *)"LLongFloatFunctor1___call__", _wrap_LLongFloatFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"LLongFloatFunctor1_swigregister", LLongFloatFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_LLongDoubleFunctor1", _wrap_delete_LLongDoubleFunctor1, METH_VARARGS, NULL},
	{ (char *)"LLongDoubleFunctor1___call__", _wrap_LLongDoubleFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"LLongDoubleFunctor1_swigregister", LLongDoubleFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_FloatUCharFunctor1", _wrap_delete_FloatUCharFunctor1, METH_VARARGS, NULL},
	{ (char *)"FloatUCharFunctor1___call__", _wrap_FloatUCharFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"FloatUCharFunctor1_swigregister", FloatUCharFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_FloatIntFunctor1", _wrap_delete_FloatIntFunctor1, METH_VARARGS, NULL},
	{ (char *)"FloatIntFunctor1___call__", _wrap_FloatIntFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"FloatIntFunctor1_swigregister", FloatIntFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_FloatLLongFunctor1", _wrap_delete_FloatLLongFunctor1, METH_VARARGS, NULL},
	{ (char *)"FloatLLongFunctor1___call__", _wrap_FloatLLongFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"FloatLLongFunctor1_swigregister", FloatLLongFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_FloatFloatFunctor1", _wrap_delete_FloatFloatFunctor1, METH_VARARGS, NULL},
	{ (char *)"FloatFloatFunctor1___call__", _wrap_FloatFloatFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"FloatFloatFunctor1_swigregister", FloatFloatFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_FloatDoubleFunctor1", _wrap_delete_FloatDoubleFunctor1, METH_VARARGS, NULL},
	{ (char *)"FloatDoubleFunctor1___call__", _wrap_FloatDoubleFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"FloatDoubleFunctor1_swigregister", FloatDoubleFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleUCharFunctor1", _wrap_delete_DoubleUCharFunctor1, METH_VARARGS, NULL},
	{ (char *)"DoubleUCharFunctor1___call__", _wrap_DoubleUCharFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleUCharFunctor1_swigregister", DoubleUCharFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleIntFunctor1", _wrap_delete_DoubleIntFunctor1, METH_VARARGS, NULL},
	{ (char *)"DoubleIntFunctor1___call__", _wrap_DoubleIntFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleIntFunctor1_swigregister", DoubleIntFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleLLongFunctor1", _wrap_delete_DoubleLLongFunctor1, METH_VARARGS, NULL},
	{ (char *)"DoubleLLongFunctor1___call__", _wrap_DoubleLLongFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleLLongFunctor1_swigregister", DoubleLLongFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleFloatFunctor1", _wrap_delete_DoubleFloatFunctor1, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatFunctor1___call__", _wrap_DoubleFloatFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatFunctor1_swigregister", DoubleFloatFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleDoubleFunctor1", _wrap_delete_DoubleDoubleFunctor1, METH_VARARGS, NULL},
	{ (char *)"DoubleDoubleFunctor1___call__", _wrap_DoubleDoubleFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleDoubleFunctor1_swigregister", DoubleDoubleFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharUCharFcnFunctor1", _wrap_new_UCharUCharFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_UCharUCharFcnFunctor1", _wrap_delete_UCharUCharFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"UCharUCharFcnFunctor1___call__", _wrap_UCharUCharFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"UCharUCharFcnFunctor1___eq__", _wrap_UCharUCharFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"UCharUCharFcnFunctor1___ne__", _wrap_UCharUCharFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"UCharUCharFcnFunctor1_swigregister", UCharUCharFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharIntFcnFunctor1", _wrap_new_UCharIntFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_UCharIntFcnFunctor1", _wrap_delete_UCharIntFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"UCharIntFcnFunctor1___call__", _wrap_UCharIntFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"UCharIntFcnFunctor1___eq__", _wrap_UCharIntFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"UCharIntFcnFunctor1___ne__", _wrap_UCharIntFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"UCharIntFcnFunctor1_swigregister", UCharIntFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharLLongFcnFunctor1", _wrap_new_UCharLLongFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_UCharLLongFcnFunctor1", _wrap_delete_UCharLLongFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"UCharLLongFcnFunctor1___call__", _wrap_UCharLLongFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"UCharLLongFcnFunctor1___eq__", _wrap_UCharLLongFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"UCharLLongFcnFunctor1___ne__", _wrap_UCharLLongFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"UCharLLongFcnFunctor1_swigregister", UCharLLongFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharFloatFcnFunctor1", _wrap_new_UCharFloatFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_UCharFloatFcnFunctor1", _wrap_delete_UCharFloatFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"UCharFloatFcnFunctor1___call__", _wrap_UCharFloatFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"UCharFloatFcnFunctor1___eq__", _wrap_UCharFloatFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"UCharFloatFcnFunctor1___ne__", _wrap_UCharFloatFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"UCharFloatFcnFunctor1_swigregister", UCharFloatFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharDoubleFcnFunctor1", _wrap_new_UCharDoubleFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_UCharDoubleFcnFunctor1", _wrap_delete_UCharDoubleFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"UCharDoubleFcnFunctor1___call__", _wrap_UCharDoubleFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"UCharDoubleFcnFunctor1___eq__", _wrap_UCharDoubleFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"UCharDoubleFcnFunctor1___ne__", _wrap_UCharDoubleFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"UCharDoubleFcnFunctor1_swigregister", UCharDoubleFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntUCharFcnFunctor1", _wrap_new_IntUCharFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_IntUCharFcnFunctor1", _wrap_delete_IntUCharFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"IntUCharFcnFunctor1___call__", _wrap_IntUCharFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"IntUCharFcnFunctor1___eq__", _wrap_IntUCharFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"IntUCharFcnFunctor1___ne__", _wrap_IntUCharFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"IntUCharFcnFunctor1_swigregister", IntUCharFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntIntFcnFunctor1", _wrap_new_IntIntFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_IntIntFcnFunctor1", _wrap_delete_IntIntFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"IntIntFcnFunctor1___call__", _wrap_IntIntFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"IntIntFcnFunctor1___eq__", _wrap_IntIntFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"IntIntFcnFunctor1___ne__", _wrap_IntIntFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"IntIntFcnFunctor1_swigregister", IntIntFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntLLongFcnFunctor1", _wrap_new_IntLLongFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_IntLLongFcnFunctor1", _wrap_delete_IntLLongFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"IntLLongFcnFunctor1___call__", _wrap_IntLLongFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"IntLLongFcnFunctor1___eq__", _wrap_IntLLongFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"IntLLongFcnFunctor1___ne__", _wrap_IntLLongFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"IntLLongFcnFunctor1_swigregister", IntLLongFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntFloatFcnFunctor1", _wrap_new_IntFloatFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_IntFloatFcnFunctor1", _wrap_delete_IntFloatFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"IntFloatFcnFunctor1___call__", _wrap_IntFloatFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"IntFloatFcnFunctor1___eq__", _wrap_IntFloatFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"IntFloatFcnFunctor1___ne__", _wrap_IntFloatFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"IntFloatFcnFunctor1_swigregister", IntFloatFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntDoubleFcnFunctor1", _wrap_new_IntDoubleFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_IntDoubleFcnFunctor1", _wrap_delete_IntDoubleFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"IntDoubleFcnFunctor1___call__", _wrap_IntDoubleFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"IntDoubleFcnFunctor1___eq__", _wrap_IntDoubleFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"IntDoubleFcnFunctor1___ne__", _wrap_IntDoubleFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"IntDoubleFcnFunctor1_swigregister", IntDoubleFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongUCharFcnFunctor1", _wrap_new_LLongUCharFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_LLongUCharFcnFunctor1", _wrap_delete_LLongUCharFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"LLongUCharFcnFunctor1___call__", _wrap_LLongUCharFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"LLongUCharFcnFunctor1___eq__", _wrap_LLongUCharFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"LLongUCharFcnFunctor1___ne__", _wrap_LLongUCharFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"LLongUCharFcnFunctor1_swigregister", LLongUCharFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongIntFcnFunctor1", _wrap_new_LLongIntFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_LLongIntFcnFunctor1", _wrap_delete_LLongIntFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"LLongIntFcnFunctor1___call__", _wrap_LLongIntFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"LLongIntFcnFunctor1___eq__", _wrap_LLongIntFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"LLongIntFcnFunctor1___ne__", _wrap_LLongIntFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"LLongIntFcnFunctor1_swigregister", LLongIntFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongLLongFcnFunctor1", _wrap_new_LLongLLongFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_LLongLLongFcnFunctor1", _wrap_delete_LLongLLongFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"LLongLLongFcnFunctor1___call__", _wrap_LLongLLongFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"LLongLLongFcnFunctor1___eq__", _wrap_LLongLLongFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"LLongLLongFcnFunctor1___ne__", _wrap_LLongLLongFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"LLongLLongFcnFunctor1_swigregister", LLongLLongFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongFloatFcnFunctor1", _wrap_new_LLongFloatFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_LLongFloatFcnFunctor1", _wrap_delete_LLongFloatFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"LLongFloatFcnFunctor1___call__", _wrap_LLongFloatFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"LLongFloatFcnFunctor1___eq__", _wrap_LLongFloatFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"LLongFloatFcnFunctor1___ne__", _wrap_LLongFloatFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"LLongFloatFcnFunctor1_swigregister", LLongFloatFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongDoubleFcnFunctor1", _wrap_new_LLongDoubleFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_LLongDoubleFcnFunctor1", _wrap_delete_LLongDoubleFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"LLongDoubleFcnFunctor1___call__", _wrap_LLongDoubleFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"LLongDoubleFcnFunctor1___eq__", _wrap_LLongDoubleFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"LLongDoubleFcnFunctor1___ne__", _wrap_LLongDoubleFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"LLongDoubleFcnFunctor1_swigregister", LLongDoubleFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatUCharFcnFunctor1", _wrap_new_FloatUCharFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_FloatUCharFcnFunctor1", _wrap_delete_FloatUCharFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"FloatUCharFcnFunctor1___call__", _wrap_FloatUCharFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"FloatUCharFcnFunctor1___eq__", _wrap_FloatUCharFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatUCharFcnFunctor1___ne__", _wrap_FloatUCharFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatUCharFcnFunctor1_swigregister", FloatUCharFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatIntFcnFunctor1", _wrap_new_FloatIntFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_FloatIntFcnFunctor1", _wrap_delete_FloatIntFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"FloatIntFcnFunctor1___call__", _wrap_FloatIntFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"FloatIntFcnFunctor1___eq__", _wrap_FloatIntFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatIntFcnFunctor1___ne__", _wrap_FloatIntFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatIntFcnFunctor1_swigregister", FloatIntFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatLLongFcnFunctor1", _wrap_new_FloatLLongFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_FloatLLongFcnFunctor1", _wrap_delete_FloatLLongFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"FloatLLongFcnFunctor1___call__", _wrap_FloatLLongFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"FloatLLongFcnFunctor1___eq__", _wrap_FloatLLongFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatLLongFcnFunctor1___ne__", _wrap_FloatLLongFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatLLongFcnFunctor1_swigregister", FloatLLongFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatFloatFcnFunctor1", _wrap_new_FloatFloatFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_FloatFloatFcnFunctor1", _wrap_delete_FloatFloatFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"FloatFloatFcnFunctor1___call__", _wrap_FloatFloatFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"FloatFloatFcnFunctor1___eq__", _wrap_FloatFloatFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatFloatFcnFunctor1___ne__", _wrap_FloatFloatFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatFloatFcnFunctor1_swigregister", FloatFloatFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatDoubleFcnFunctor1", _wrap_new_FloatDoubleFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_FloatDoubleFcnFunctor1", _wrap_delete_FloatDoubleFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"FloatDoubleFcnFunctor1___call__", _wrap_FloatDoubleFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"FloatDoubleFcnFunctor1___eq__", _wrap_FloatDoubleFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatDoubleFcnFunctor1___ne__", _wrap_FloatDoubleFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatDoubleFcnFunctor1_swigregister", FloatDoubleFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleUCharFcnFunctor1", _wrap_new_DoubleUCharFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleUCharFcnFunctor1", _wrap_delete_DoubleUCharFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"DoubleUCharFcnFunctor1___call__", _wrap_DoubleUCharFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleUCharFcnFunctor1___eq__", _wrap_DoubleUCharFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleUCharFcnFunctor1___ne__", _wrap_DoubleUCharFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleUCharFcnFunctor1_swigregister", DoubleUCharFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleIntFcnFunctor1", _wrap_new_DoubleIntFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleIntFcnFunctor1", _wrap_delete_DoubleIntFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"DoubleIntFcnFunctor1___call__", _wrap_DoubleIntFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleIntFcnFunctor1___eq__", _wrap_DoubleIntFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleIntFcnFunctor1___ne__", _wrap_DoubleIntFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleIntFcnFunctor1_swigregister", DoubleIntFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleLLongFcnFunctor1", _wrap_new_DoubleLLongFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleLLongFcnFunctor1", _wrap_delete_DoubleLLongFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"DoubleLLongFcnFunctor1___call__", _wrap_DoubleLLongFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleLLongFcnFunctor1___eq__", _wrap_DoubleLLongFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleLLongFcnFunctor1___ne__", _wrap_DoubleLLongFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleLLongFcnFunctor1_swigregister", DoubleLLongFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleFloatFcnFunctor1", _wrap_new_DoubleFloatFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleFloatFcnFunctor1", _wrap_delete_DoubleFloatFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatFcnFunctor1___call__", _wrap_DoubleFloatFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatFcnFunctor1___eq__", _wrap_DoubleFloatFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatFcnFunctor1___ne__", _wrap_DoubleFloatFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleFloatFcnFunctor1_swigregister", DoubleFloatFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleDoubleFcnFunctor1", _wrap_new_DoubleDoubleFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleDoubleFcnFunctor1", _wrap_delete_DoubleDoubleFcnFunctor1, METH_VARARGS, NULL},
	{ (char *)"DoubleDoubleFcnFunctor1___call__", _wrap_DoubleDoubleFcnFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleDoubleFcnFunctor1___eq__", _wrap_DoubleDoubleFcnFunctor1___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleDoubleFcnFunctor1___ne__", _wrap_DoubleDoubleFcnFunctor1___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleDoubleFcnFunctor1_swigregister", DoubleDoubleFcnFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_UCharSame", _wrap_delete_UCharSame, METH_VARARGS, NULL},
	{ (char *)"UCharSame___call__", _wrap_UCharSame___call__, METH_VARARGS, NULL},
	{ (char *)"UCharSame___eq__", _wrap_UCharSame___eq__, METH_VARARGS, NULL},
	{ (char *)"UCharSame___ne__", _wrap_UCharSame___ne__, METH_VARARGS, NULL},
	{ (char *)"new_UCharSame", _wrap_new_UCharSame, METH_VARARGS, NULL},
	{ (char *)"UCharSame_swigregister", UCharSame_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_IntSame", _wrap_delete_IntSame, METH_VARARGS, NULL},
	{ (char *)"IntSame___call__", _wrap_IntSame___call__, METH_VARARGS, NULL},
	{ (char *)"IntSame___eq__", _wrap_IntSame___eq__, METH_VARARGS, NULL},
	{ (char *)"IntSame___ne__", _wrap_IntSame___ne__, METH_VARARGS, NULL},
	{ (char *)"new_IntSame", _wrap_new_IntSame, METH_VARARGS, NULL},
	{ (char *)"IntSame_swigregister", IntSame_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_LLongSame", _wrap_delete_LLongSame, METH_VARARGS, NULL},
	{ (char *)"LLongSame___call__", _wrap_LLongSame___call__, METH_VARARGS, NULL},
	{ (char *)"LLongSame___eq__", _wrap_LLongSame___eq__, METH_VARARGS, NULL},
	{ (char *)"LLongSame___ne__", _wrap_LLongSame___ne__, METH_VARARGS, NULL},
	{ (char *)"new_LLongSame", _wrap_new_LLongSame, METH_VARARGS, NULL},
	{ (char *)"LLongSame_swigregister", LLongSame_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_FloatSame", _wrap_delete_FloatSame, METH_VARARGS, NULL},
	{ (char *)"FloatSame___call__", _wrap_FloatSame___call__, METH_VARARGS, NULL},
	{ (char *)"FloatSame___eq__", _wrap_FloatSame___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatSame___ne__", _wrap_FloatSame___ne__, METH_VARARGS, NULL},
	{ (char *)"new_FloatSame", _wrap_new_FloatSame, METH_VARARGS, NULL},
	{ (char *)"FloatSame_swigregister", FloatSame_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleSame", _wrap_delete_DoubleSame, METH_VARARGS, NULL},
	{ (char *)"DoubleSame___call__", _wrap_DoubleSame___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleSame___eq__", _wrap_DoubleSame___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleSame___ne__", _wrap_DoubleSame___ne__, METH_VARARGS, NULL},
	{ (char *)"new_DoubleSame", _wrap_new_DoubleSame, METH_VARARGS, NULL},
	{ (char *)"DoubleSame_swigregister", DoubleSame_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_LongDoubleLongDoubleFunctor1", _wrap_delete_LongDoubleLongDoubleFunctor1, METH_VARARGS, NULL},
	{ (char *)"LongDoubleLongDoubleFunctor1___call__", _wrap_LongDoubleLongDoubleFunctor1___call__, METH_VARARGS, NULL},
	{ (char *)"LongDoubleLongDoubleFunctor1_swigregister", LongDoubleLongDoubleFunctor1_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleDoubleDoubleFunctor2", _wrap_delete_DoubleDoubleDoubleFunctor2, METH_VARARGS, NULL},
	{ (char *)"DoubleDoubleDoubleFunctor2___call__", _wrap_DoubleDoubleDoubleFunctor2___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleDoubleDoubleFunctor2_swigregister", DoubleDoubleDoubleFunctor2_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleDoubleDoubleFcnFunctor2", _wrap_new_DoubleDoubleDoubleFcnFunctor2, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleDoubleDoubleFcnFunctor2", _wrap_delete_DoubleDoubleDoubleFcnFunctor2, METH_VARARGS, NULL},
	{ (char *)"DoubleDoubleDoubleFcnFunctor2___call__", _wrap_DoubleDoubleDoubleFcnFunctor2___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleDoubleDoubleFcnFunctor2___eq__", _wrap_DoubleDoubleDoubleFcnFunctor2___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleDoubleDoubleFcnFunctor2___ne__", _wrap_DoubleDoubleDoubleFcnFunctor2___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleDoubleDoubleFcnFunctor2_swigregister", DoubleDoubleDoubleFcnFunctor2_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsDistribution1D", _wrap_delete_AbsDistribution1D, METH_VARARGS, NULL},
	{ (char *)"AbsDistribution1D_density", _wrap_AbsDistribution1D_density, METH_VARARGS, NULL},
	{ (char *)"AbsDistribution1D_cdf", _wrap_AbsDistribution1D_cdf, METH_VARARGS, NULL},
	{ (char *)"AbsDistribution1D_exceedance", _wrap_AbsDistribution1D_exceedance, METH_VARARGS, NULL},
	{ (char *)"AbsDistribution1D_quantile", _wrap_AbsDistribution1D_quantile, METH_VARARGS, NULL},
	{ (char *)"AbsDistribution1D___eq__", _wrap_AbsDistribution1D___eq__, METH_VARARGS, NULL},
	{ (char *)"AbsDistribution1D___ne__", _wrap_AbsDistribution1D___ne__, METH_VARARGS, NULL},
	{ (char *)"AbsDistribution1D_clone", _wrap_AbsDistribution1D_clone, METH_VARARGS, NULL},
	{ (char *)"AbsDistribution1D_classId", _wrap_AbsDistribution1D_classId, METH_VARARGS, NULL},
	{ (char *)"AbsDistribution1D_write", _wrap_AbsDistribution1D_write, METH_VARARGS, NULL},
	{ (char *)"AbsDistribution1D_classname", _wrap_AbsDistribution1D_classname, METH_VARARGS, NULL},
	{ (char *)"AbsDistribution1D_version", _wrap_AbsDistribution1D_version, METH_VARARGS, NULL},
	{ (char *)"AbsDistribution1D_read", _wrap_AbsDistribution1D_read, METH_VARARGS, NULL},
	{ (char *)"AbsDistribution1D_random", _wrap_AbsDistribution1D_random, METH_VARARGS, NULL},
	{ (char *)"AbsDistribution1D_generate", _wrap_AbsDistribution1D_generate, METH_VARARGS, NULL},
	{ (char *)"AbsDistribution1D_swigregister", AbsDistribution1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsScalableDistribution1D", _wrap_delete_AbsScalableDistribution1D, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistribution1D_location", _wrap_AbsScalableDistribution1D_location, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistribution1D_scale", _wrap_AbsScalableDistribution1D_scale, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistribution1D_setLocation", _wrap_AbsScalableDistribution1D_setLocation, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistribution1D_setScale", _wrap_AbsScalableDistribution1D_setScale, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistribution1D_density", _wrap_AbsScalableDistribution1D_density, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistribution1D_cdf", _wrap_AbsScalableDistribution1D_cdf, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistribution1D_exceedance", _wrap_AbsScalableDistribution1D_exceedance, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistribution1D_quantile", _wrap_AbsScalableDistribution1D_quantile, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistribution1D_clone", _wrap_AbsScalableDistribution1D_clone, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistribution1D_classId", _wrap_AbsScalableDistribution1D_classId, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistribution1D_write", _wrap_AbsScalableDistribution1D_write, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistribution1D_read", _wrap_AbsScalableDistribution1D_read, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistribution1D_swigregister", AbsScalableDistribution1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DensityFunctor1D", _wrap_new_DensityFunctor1D, METH_VARARGS, NULL},
	{ (char *)"delete_DensityFunctor1D", _wrap_delete_DensityFunctor1D, METH_VARARGS, NULL},
	{ (char *)"DensityFunctor1D___call__", _wrap_DensityFunctor1D___call__, METH_VARARGS, NULL},
	{ (char *)"DensityFunctor1D_swigregister", DensityFunctor1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DensitySquaredFunctor1D", _wrap_new_DensitySquaredFunctor1D, METH_VARARGS, NULL},
	{ (char *)"delete_DensitySquaredFunctor1D", _wrap_delete_DensitySquaredFunctor1D, METH_VARARGS, NULL},
	{ (char *)"DensitySquaredFunctor1D___call__", _wrap_DensitySquaredFunctor1D___call__, METH_VARARGS, NULL},
	{ (char *)"DensitySquaredFunctor1D_swigregister", DensitySquaredFunctor1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_CdfFunctor1D", _wrap_new_CdfFunctor1D, METH_VARARGS, NULL},
	{ (char *)"delete_CdfFunctor1D", _wrap_delete_CdfFunctor1D, METH_VARARGS, NULL},
	{ (char *)"CdfFunctor1D___call__", _wrap_CdfFunctor1D___call__, METH_VARARGS, NULL},
	{ (char *)"CdfFunctor1D_swigregister", CdfFunctor1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ExceedanceFunctor1D", _wrap_new_ExceedanceFunctor1D, METH_VARARGS, NULL},
	{ (char *)"delete_ExceedanceFunctor1D", _wrap_delete_ExceedanceFunctor1D, METH_VARARGS, NULL},
	{ (char *)"ExceedanceFunctor1D___call__", _wrap_ExceedanceFunctor1D___call__, METH_VARARGS, NULL},
	{ (char *)"ExceedanceFunctor1D_swigregister", ExceedanceFunctor1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_QuantileFunctor1D", _wrap_new_QuantileFunctor1D, METH_VARARGS, NULL},
	{ (char *)"delete_QuantileFunctor1D", _wrap_delete_QuantileFunctor1D, METH_VARARGS, NULL},
	{ (char *)"QuantileFunctor1D___call__", _wrap_QuantileFunctor1D___call__, METH_VARARGS, NULL},
	{ (char *)"QuantileFunctor1D_swigregister", QuantileFunctor1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_AbsDistribution1D", _wrap_new_ArchiveRecord_AbsDistribution1D, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_AbsDistribution1D", _wrap_delete_ArchiveRecord_AbsDistribution1D, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_AbsDistribution1D_swigregister", ArchiveRecord_AbsDistribution1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsKDE1DKernel", _wrap_delete_AbsKDE1DKernel, METH_VARARGS, NULL},
	{ (char *)"AbsKDE1DKernel_xmin", _wrap_AbsKDE1DKernel_xmin, METH_VARARGS, NULL},
	{ (char *)"AbsKDE1DKernel_xmax", _wrap_AbsKDE1DKernel_xmax, METH_VARARGS, NULL},
	{ (char *)"AbsKDE1DKernel___call__", _wrap_AbsKDE1DKernel___call__, METH_VARARGS, NULL},
	{ (char *)"AbsKDE1DKernel_clone", _wrap_AbsKDE1DKernel_clone, METH_VARARGS, NULL},
	{ (char *)"AbsKDE1DKernel_momentIntegral", _wrap_AbsKDE1DKernel_momentIntegral, METH_VARARGS, NULL},
	{ (char *)"AbsKDE1DKernel_squaredIntegral", _wrap_AbsKDE1DKernel_squaredIntegral, METH_VARARGS, NULL},
	{ (char *)"AbsKDE1DKernel_looKde", _wrap_AbsKDE1DKernel_looKde, METH_VARARGS, NULL},
	{ (char *)"AbsKDE1DKernel_kde", _wrap_AbsKDE1DKernel_kde, METH_VARARGS, NULL},
	{ (char *)"AbsKDE1DKernel_reverseKde", _wrap_AbsKDE1DKernel_reverseKde, METH_VARARGS, NULL},
	{ (char *)"AbsKDE1DKernel_integratedSquaredError", _wrap_AbsKDE1DKernel_integratedSquaredError, METH_VARARGS, NULL},
	{ (char *)"AbsKDE1DKernel_integratedKdeSquared", _wrap_AbsKDE1DKernel_integratedKdeSquared, METH_VARARGS, NULL},
	{ (char *)"AbsKDE1DKernel_swigregister", AbsKDE1DKernel_swigregister, METH_VARARGS, NULL},
	{ (char *)"KDE1DDensityKernel_clone", _wrap_KDE1DDensityKernel_clone, METH_VARARGS, NULL},
	{ (char *)"delete_KDE1DDensityKernel", _wrap_delete_KDE1DDensityKernel, METH_VARARGS, NULL},
	{ (char *)"KDE1DDensityKernel_xmin", _wrap_KDE1DDensityKernel_xmin, METH_VARARGS, NULL},
	{ (char *)"KDE1DDensityKernel_xmax", _wrap_KDE1DDensityKernel_xmax, METH_VARARGS, NULL},
	{ (char *)"KDE1DDensityKernel___call__", _wrap_KDE1DDensityKernel___call__, METH_VARARGS, NULL},
	{ (char *)"KDE1DDensityKernel_swigregister", KDE1DDensityKernel_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleKDE1DLSCVFunctorHelper", _wrap_new_DoubleKDE1DLSCVFunctorHelper, METH_VARARGS, NULL},
	{ (char *)"DoubleKDE1DLSCVFunctorHelper___call__", _wrap_DoubleKDE1DLSCVFunctorHelper___call__, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleKDE1DLSCVFunctorHelper", _wrap_delete_DoubleKDE1DLSCVFunctorHelper, METH_VARARGS, NULL},
	{ (char *)"DoubleKDE1DLSCVFunctorHelper_swigregister", DoubleKDE1DLSCVFunctorHelper_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleKDE1DRLCVFunctorHelper", _wrap_new_DoubleKDE1DRLCVFunctorHelper, METH_VARARGS, NULL},
	{ (char *)"DoubleKDE1DRLCVFunctorHelper___call__", _wrap_DoubleKDE1DRLCVFunctorHelper___call__, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleKDE1DRLCVFunctorHelper", _wrap_delete_DoubleKDE1DRLCVFunctorHelper, METH_VARARGS, NULL},
	{ (char *)"DoubleKDE1DRLCVFunctorHelper_swigregister", DoubleKDE1DRLCVFunctorHelper_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsDiscreteDistribution1D", _wrap_delete_AbsDiscreteDistribution1D, METH_VARARGS, NULL},
	{ (char *)"AbsDiscreteDistribution1D_probability", _wrap_AbsDiscreteDistribution1D_probability, METH_VARARGS, NULL},
	{ (char *)"AbsDiscreteDistribution1D_cdf", _wrap_AbsDiscreteDistribution1D_cdf, METH_VARARGS, NULL},
	{ (char *)"AbsDiscreteDistribution1D_exceedance", _wrap_AbsDiscreteDistribution1D_exceedance, METH_VARARGS, NULL},
	{ (char *)"AbsDiscreteDistribution1D_quantile", _wrap_AbsDiscreteDistribution1D_quantile, METH_VARARGS, NULL},
	{ (char *)"AbsDiscreteDistribution1D___eq__", _wrap_AbsDiscreteDistribution1D___eq__, METH_VARARGS, NULL},
	{ (char *)"AbsDiscreteDistribution1D___ne__", _wrap_AbsDiscreteDistribution1D___ne__, METH_VARARGS, NULL},
	{ (char *)"AbsDiscreteDistribution1D_clone", _wrap_AbsDiscreteDistribution1D_clone, METH_VARARGS, NULL},
	{ (char *)"AbsDiscreteDistribution1D_classId", _wrap_AbsDiscreteDistribution1D_classId, METH_VARARGS, NULL},
	{ (char *)"AbsDiscreteDistribution1D_write", _wrap_AbsDiscreteDistribution1D_write, METH_VARARGS, NULL},
	{ (char *)"AbsDiscreteDistribution1D_classname", _wrap_AbsDiscreteDistribution1D_classname, METH_VARARGS, NULL},
	{ (char *)"AbsDiscreteDistribution1D_version", _wrap_AbsDiscreteDistribution1D_version, METH_VARARGS, NULL},
	{ (char *)"AbsDiscreteDistribution1D_read", _wrap_AbsDiscreteDistribution1D_read, METH_VARARGS, NULL},
	{ (char *)"AbsDiscreteDistribution1D_random", _wrap_AbsDiscreteDistribution1D_random, METH_VARARGS, NULL},
	{ (char *)"AbsDiscreteDistribution1D_generate", _wrap_AbsDiscreteDistribution1D_generate, METH_VARARGS, NULL},
	{ (char *)"AbsDiscreteDistribution1D_swigregister", AbsDiscreteDistribution1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_ShiftableDiscreteDistribution1D", _wrap_delete_ShiftableDiscreteDistribution1D, METH_VARARGS, NULL},
	{ (char *)"ShiftableDiscreteDistribution1D_location", _wrap_ShiftableDiscreteDistribution1D_location, METH_VARARGS, NULL},
	{ (char *)"ShiftableDiscreteDistribution1D_setLocation", _wrap_ShiftableDiscreteDistribution1D_setLocation, METH_VARARGS, NULL},
	{ (char *)"ShiftableDiscreteDistribution1D_probability", _wrap_ShiftableDiscreteDistribution1D_probability, METH_VARARGS, NULL},
	{ (char *)"ShiftableDiscreteDistribution1D_cdf", _wrap_ShiftableDiscreteDistribution1D_cdf, METH_VARARGS, NULL},
	{ (char *)"ShiftableDiscreteDistribution1D_exceedance", _wrap_ShiftableDiscreteDistribution1D_exceedance, METH_VARARGS, NULL},
	{ (char *)"ShiftableDiscreteDistribution1D_quantile", _wrap_ShiftableDiscreteDistribution1D_quantile, METH_VARARGS, NULL},
	{ (char *)"ShiftableDiscreteDistribution1D_clone", _wrap_ShiftableDiscreteDistribution1D_clone, METH_VARARGS, NULL},
	{ (char *)"ShiftableDiscreteDistribution1D_classId", _wrap_ShiftableDiscreteDistribution1D_classId, METH_VARARGS, NULL},
	{ (char *)"ShiftableDiscreteDistribution1D_swigregister", ShiftableDiscreteDistribution1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsDiscreteDistribution1DDistance", _wrap_delete_AbsDiscreteDistribution1DDistance, METH_VARARGS, NULL},
	{ (char *)"AbsDiscreteDistribution1DDistance___call__", _wrap_AbsDiscreteDistribution1DDistance___call__, METH_VARARGS, NULL},
	{ (char *)"AbsDiscreteDistribution1DDistance_swigregister", AbsDiscreteDistribution1DDistance_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_AbsDiscreteDistribution1D", _wrap_new_ArchiveRecord_AbsDiscreteDistribution1D, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_AbsDiscreteDistribution1D", _wrap_delete_ArchiveRecord_AbsDiscreteDistribution1D, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_AbsDiscreteDistribution1D_swigregister", ArchiveRecord_AbsDiscreteDistribution1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"GridAxis_coords", _wrap_GridAxis_coords, METH_VARARGS, NULL},
	{ (char *)"GridAxis_label", _wrap_GridAxis_label, METH_VARARGS, NULL},
	{ (char *)"GridAxis_usesLogSpace", _wrap_GridAxis_usesLogSpace, METH_VARARGS, NULL},
	{ (char *)"GridAxis_getInterval", _wrap_GridAxis_getInterval, METH_VARARGS, NULL},
	{ (char *)"GridAxis_linearInterval", _wrap_GridAxis_linearInterval, METH_VARARGS, NULL},
	{ (char *)"GridAxis_nCoords", _wrap_GridAxis_nCoords, METH_VARARGS, NULL},
	{ (char *)"GridAxis_coordinate", _wrap_GridAxis_coordinate, METH_VARARGS, NULL},
	{ (char *)"GridAxis_min", _wrap_GridAxis_min, METH_VARARGS, NULL},
	{ (char *)"GridAxis_max", _wrap_GridAxis_max, METH_VARARGS, NULL},
	{ (char *)"GridAxis_length", _wrap_GridAxis_length, METH_VARARGS, NULL},
	{ (char *)"GridAxis_isUniform", _wrap_GridAxis_isUniform, METH_VARARGS, NULL},
	{ (char *)"GridAxis_nIntervals", _wrap_GridAxis_nIntervals, METH_VARARGS, NULL},
	{ (char *)"GridAxis_intervalWidth", _wrap_GridAxis_intervalWidth, METH_VARARGS, NULL},
	{ (char *)"GridAxis___eq__", _wrap_GridAxis___eq__, METH_VARARGS, NULL},
	{ (char *)"GridAxis___ne__", _wrap_GridAxis___ne__, METH_VARARGS, NULL},
	{ (char *)"GridAxis_isClose", _wrap_GridAxis_isClose, METH_VARARGS, NULL},
	{ (char *)"GridAxis_setLabel", _wrap_GridAxis_setLabel, METH_VARARGS, NULL},
	{ (char *)"GridAxis_classId", _wrap_GridAxis_classId, METH_VARARGS, NULL},
	{ (char *)"GridAxis_write", _wrap_GridAxis_write, METH_VARARGS, NULL},
	{ (char *)"GridAxis_classname", _wrap_GridAxis_classname, METH_VARARGS, NULL},
	{ (char *)"GridAxis_version", _wrap_GridAxis_version, METH_VARARGS, NULL},
	{ (char *)"GridAxis_read", _wrap_GridAxis_read, METH_VARARGS, NULL},
	{ (char *)"GridAxis_range", _wrap_GridAxis_range, METH_VARARGS, NULL},
	{ (char *)"new_GridAxis", _wrap_new_GridAxis, METH_VARARGS, NULL},
	{ (char *)"delete_GridAxis", _wrap_delete_GridAxis, METH_VARARGS, NULL},
	{ (char *)"GridAxis_swigregister", GridAxis_swigregister, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_iterator", _wrap_GridAxisVector_iterator, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector___nonzero__", _wrap_GridAxisVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector___bool__", _wrap_GridAxisVector___bool__, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector___len__", _wrap_GridAxisVector___len__, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector___getslice__", _wrap_GridAxisVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector___setslice__", _wrap_GridAxisVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector___delslice__", _wrap_GridAxisVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector___delitem__", _wrap_GridAxisVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector___getitem__", _wrap_GridAxisVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector___setitem__", _wrap_GridAxisVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_pop", _wrap_GridAxisVector_pop, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_append", _wrap_GridAxisVector_append, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_empty", _wrap_GridAxisVector_empty, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_size", _wrap_GridAxisVector_size, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_swap", _wrap_GridAxisVector_swap, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_begin", _wrap_GridAxisVector_begin, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_end", _wrap_GridAxisVector_end, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_rbegin", _wrap_GridAxisVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_rend", _wrap_GridAxisVector_rend, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_clear", _wrap_GridAxisVector_clear, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_get_allocator", _wrap_GridAxisVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_pop_back", _wrap_GridAxisVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_erase", _wrap_GridAxisVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_GridAxisVector", _wrap_new_GridAxisVector, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_push_back", _wrap_GridAxisVector_push_back, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_front", _wrap_GridAxisVector_front, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_back", _wrap_GridAxisVector_back, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_assign", _wrap_GridAxisVector_assign, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_resize", _wrap_GridAxisVector_resize, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_insert", _wrap_GridAxisVector_insert, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_reserve", _wrap_GridAxisVector_reserve, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_capacity", _wrap_GridAxisVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_GridAxisVector", _wrap_delete_GridAxisVector, METH_VARARGS, NULL},
	{ (char *)"GridAxisVector_swigregister", GridAxisVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsMultivariateFunctor", _wrap_delete_AbsMultivariateFunctor, METH_VARARGS, NULL},
	{ (char *)"AbsMultivariateFunctor___call__", _wrap_AbsMultivariateFunctor___call__, METH_VARARGS, NULL},
	{ (char *)"AbsMultivariateFunctor_minDim", _wrap_AbsMultivariateFunctor_minDim, METH_VARARGS, NULL},
	{ (char *)"AbsMultivariateFunctor_maxDim", _wrap_AbsMultivariateFunctor_maxDim, METH_VARARGS, NULL},
	{ (char *)"AbsMultivariateFunctor_swigregister", AbsMultivariateFunctor_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Uniform1D", _wrap_new_Uniform1D, METH_VARARGS, NULL},
	{ (char *)"Uniform1D_clone", _wrap_Uniform1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_Uniform1D", _wrap_delete_Uniform1D, METH_VARARGS, NULL},
	{ (char *)"Uniform1D_classId", _wrap_Uniform1D_classId, METH_VARARGS, NULL},
	{ (char *)"Uniform1D_classname", _wrap_Uniform1D_classname, METH_VARARGS, NULL},
	{ (char *)"Uniform1D_version", _wrap_Uniform1D_version, METH_VARARGS, NULL},
	{ (char *)"Uniform1D_read", _wrap_Uniform1D_read, METH_VARARGS, NULL},
	{ (char *)"Uniform1D_swigregister", Uniform1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"IsoscelesTriangle1D_clone", _wrap_IsoscelesTriangle1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_IsoscelesTriangle1D", _wrap_delete_IsoscelesTriangle1D, METH_VARARGS, NULL},
	{ (char *)"IsoscelesTriangle1D_classId", _wrap_IsoscelesTriangle1D_classId, METH_VARARGS, NULL},
	{ (char *)"IsoscelesTriangle1D_classname", _wrap_IsoscelesTriangle1D_classname, METH_VARARGS, NULL},
	{ (char *)"IsoscelesTriangle1D_version", _wrap_IsoscelesTriangle1D_version, METH_VARARGS, NULL},
	{ (char *)"IsoscelesTriangle1D_read", _wrap_IsoscelesTriangle1D_read, METH_VARARGS, NULL},
	{ (char *)"IsoscelesTriangle1D_swigregister", IsoscelesTriangle1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Exponential1D", _wrap_new_Exponential1D, METH_VARARGS, NULL},
	{ (char *)"Exponential1D_clone", _wrap_Exponential1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_Exponential1D", _wrap_delete_Exponential1D, METH_VARARGS, NULL},
	{ (char *)"Exponential1D_classId", _wrap_Exponential1D_classId, METH_VARARGS, NULL},
	{ (char *)"Exponential1D_classname", _wrap_Exponential1D_classname, METH_VARARGS, NULL},
	{ (char *)"Exponential1D_version", _wrap_Exponential1D_version, METH_VARARGS, NULL},
	{ (char *)"Exponential1D_read", _wrap_Exponential1D_read, METH_VARARGS, NULL},
	{ (char *)"Exponential1D_swigregister", Exponential1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"Logistic1D_clone", _wrap_Logistic1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_Logistic1D", _wrap_delete_Logistic1D, METH_VARARGS, NULL},
	{ (char *)"Logistic1D_classId", _wrap_Logistic1D_classId, METH_VARARGS, NULL},
	{ (char *)"Logistic1D_classname", _wrap_Logistic1D_classname, METH_VARARGS, NULL},
	{ (char *)"Logistic1D_version", _wrap_Logistic1D_version, METH_VARARGS, NULL},
	{ (char *)"Logistic1D_read", _wrap_Logistic1D_read, METH_VARARGS, NULL},
	{ (char *)"Logistic1D_swigregister", Logistic1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Quadratic1D", _wrap_new_Quadratic1D, METH_VARARGS, NULL},
	{ (char *)"Quadratic1D_clone", _wrap_Quadratic1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_Quadratic1D", _wrap_delete_Quadratic1D, METH_VARARGS, NULL},
	{ (char *)"Quadratic1D_a", _wrap_Quadratic1D_a, METH_VARARGS, NULL},
	{ (char *)"Quadratic1D_b", _wrap_Quadratic1D_b, METH_VARARGS, NULL},
	{ (char *)"Quadratic1D_classId", _wrap_Quadratic1D_classId, METH_VARARGS, NULL},
	{ (char *)"Quadratic1D_write", _wrap_Quadratic1D_write, METH_VARARGS, NULL},
	{ (char *)"Quadratic1D_classname", _wrap_Quadratic1D_classname, METH_VARARGS, NULL},
	{ (char *)"Quadratic1D_version", _wrap_Quadratic1D_version, METH_VARARGS, NULL},
	{ (char *)"Quadratic1D_read", _wrap_Quadratic1D_read, METH_VARARGS, NULL},
	{ (char *)"Quadratic1D_swigregister", Quadratic1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LogQuadratic1D", _wrap_new_LogQuadratic1D, METH_VARARGS, NULL},
	{ (char *)"LogQuadratic1D_clone", _wrap_LogQuadratic1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_LogQuadratic1D", _wrap_delete_LogQuadratic1D, METH_VARARGS, NULL},
	{ (char *)"LogQuadratic1D_a", _wrap_LogQuadratic1D_a, METH_VARARGS, NULL},
	{ (char *)"LogQuadratic1D_b", _wrap_LogQuadratic1D_b, METH_VARARGS, NULL},
	{ (char *)"LogQuadratic1D_classId", _wrap_LogQuadratic1D_classId, METH_VARARGS, NULL},
	{ (char *)"LogQuadratic1D_write", _wrap_LogQuadratic1D_write, METH_VARARGS, NULL},
	{ (char *)"LogQuadratic1D_classname", _wrap_LogQuadratic1D_classname, METH_VARARGS, NULL},
	{ (char *)"LogQuadratic1D_version", _wrap_LogQuadratic1D_version, METH_VARARGS, NULL},
	{ (char *)"LogQuadratic1D_read", _wrap_LogQuadratic1D_read, METH_VARARGS, NULL},
	{ (char *)"LogQuadratic1D_swigregister", LogQuadratic1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Gauss1D", _wrap_new_Gauss1D, METH_VARARGS, NULL},
	{ (char *)"Gauss1D_clone", _wrap_Gauss1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_Gauss1D", _wrap_delete_Gauss1D, METH_VARARGS, NULL},
	{ (char *)"Gauss1D_classId", _wrap_Gauss1D_classId, METH_VARARGS, NULL},
	{ (char *)"Gauss1D_classname", _wrap_Gauss1D_classname, METH_VARARGS, NULL},
	{ (char *)"Gauss1D_version", _wrap_Gauss1D_version, METH_VARARGS, NULL},
	{ (char *)"Gauss1D_read", _wrap_Gauss1D_read, METH_VARARGS, NULL},
	{ (char *)"Gauss1D_swigregister", Gauss1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_TruncatedGauss1D", _wrap_new_TruncatedGauss1D, METH_VARARGS, NULL},
	{ (char *)"TruncatedGauss1D_clone", _wrap_TruncatedGauss1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_TruncatedGauss1D", _wrap_delete_TruncatedGauss1D, METH_VARARGS, NULL},
	{ (char *)"TruncatedGauss1D_nsigma", _wrap_TruncatedGauss1D_nsigma, METH_VARARGS, NULL},
	{ (char *)"TruncatedGauss1D_classId", _wrap_TruncatedGauss1D_classId, METH_VARARGS, NULL},
	{ (char *)"TruncatedGauss1D_write", _wrap_TruncatedGauss1D_write, METH_VARARGS, NULL},
	{ (char *)"TruncatedGauss1D_classname", _wrap_TruncatedGauss1D_classname, METH_VARARGS, NULL},
	{ (char *)"TruncatedGauss1D_version", _wrap_TruncatedGauss1D_version, METH_VARARGS, NULL},
	{ (char *)"TruncatedGauss1D_read", _wrap_TruncatedGauss1D_read, METH_VARARGS, NULL},
	{ (char *)"TruncatedGauss1D_swigregister", TruncatedGauss1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"MirroredGauss1D_clone", _wrap_MirroredGauss1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_MirroredGauss1D", _wrap_delete_MirroredGauss1D, METH_VARARGS, NULL},
	{ (char *)"MirroredGauss1D_meanOn0_1", _wrap_MirroredGauss1D_meanOn0_1, METH_VARARGS, NULL},
	{ (char *)"MirroredGauss1D_sigmaOn0_1", _wrap_MirroredGauss1D_sigmaOn0_1, METH_VARARGS, NULL},
	{ (char *)"MirroredGauss1D_classId", _wrap_MirroredGauss1D_classId, METH_VARARGS, NULL},
	{ (char *)"MirroredGauss1D_write", _wrap_MirroredGauss1D_write, METH_VARARGS, NULL},
	{ (char *)"MirroredGauss1D_classname", _wrap_MirroredGauss1D_classname, METH_VARARGS, NULL},
	{ (char *)"MirroredGauss1D_version", _wrap_MirroredGauss1D_version, METH_VARARGS, NULL},
	{ (char *)"MirroredGauss1D_read", _wrap_MirroredGauss1D_read, METH_VARARGS, NULL},
	{ (char *)"MirroredGauss1D_swigregister", MirroredGauss1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"BifurcatedGauss1D_clone", _wrap_BifurcatedGauss1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_BifurcatedGauss1D", _wrap_delete_BifurcatedGauss1D, METH_VARARGS, NULL},
	{ (char *)"BifurcatedGauss1D_leftSigmaFraction", _wrap_BifurcatedGauss1D_leftSigmaFraction, METH_VARARGS, NULL},
	{ (char *)"BifurcatedGauss1D_nSigmasLeft", _wrap_BifurcatedGauss1D_nSigmasLeft, METH_VARARGS, NULL},
	{ (char *)"BifurcatedGauss1D_nSigmasRight", _wrap_BifurcatedGauss1D_nSigmasRight, METH_VARARGS, NULL},
	{ (char *)"BifurcatedGauss1D_classId", _wrap_BifurcatedGauss1D_classId, METH_VARARGS, NULL},
	{ (char *)"BifurcatedGauss1D_write", _wrap_BifurcatedGauss1D_write, METH_VARARGS, NULL},
	{ (char *)"BifurcatedGauss1D_classname", _wrap_BifurcatedGauss1D_classname, METH_VARARGS, NULL},
	{ (char *)"BifurcatedGauss1D_version", _wrap_BifurcatedGauss1D_version, METH_VARARGS, NULL},
	{ (char *)"BifurcatedGauss1D_read", _wrap_BifurcatedGauss1D_read, METH_VARARGS, NULL},
	{ (char *)"BifurcatedGauss1D_swigregister", BifurcatedGauss1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_SymmetricBeta1D", _wrap_new_SymmetricBeta1D, METH_VARARGS, NULL},
	{ (char *)"SymmetricBeta1D_clone", _wrap_SymmetricBeta1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_SymmetricBeta1D", _wrap_delete_SymmetricBeta1D, METH_VARARGS, NULL},
	{ (char *)"SymmetricBeta1D_power", _wrap_SymmetricBeta1D_power, METH_VARARGS, NULL},
	{ (char *)"SymmetricBeta1D_classId", _wrap_SymmetricBeta1D_classId, METH_VARARGS, NULL},
	{ (char *)"SymmetricBeta1D_write", _wrap_SymmetricBeta1D_write, METH_VARARGS, NULL},
	{ (char *)"SymmetricBeta1D_classname", _wrap_SymmetricBeta1D_classname, METH_VARARGS, NULL},
	{ (char *)"SymmetricBeta1D_version", _wrap_SymmetricBeta1D_version, METH_VARARGS, NULL},
	{ (char *)"SymmetricBeta1D_read", _wrap_SymmetricBeta1D_read, METH_VARARGS, NULL},
	{ (char *)"SymmetricBeta1D_swigregister", SymmetricBeta1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Beta1D", _wrap_new_Beta1D, METH_VARARGS, NULL},
	{ (char *)"Beta1D_clone", _wrap_Beta1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_Beta1D", _wrap_delete_Beta1D, METH_VARARGS, NULL},
	{ (char *)"Beta1D_alpha", _wrap_Beta1D_alpha, METH_VARARGS, NULL},
	{ (char *)"Beta1D_beta", _wrap_Beta1D_beta, METH_VARARGS, NULL},
	{ (char *)"Beta1D_classId", _wrap_Beta1D_classId, METH_VARARGS, NULL},
	{ (char *)"Beta1D_write", _wrap_Beta1D_write, METH_VARARGS, NULL},
	{ (char *)"Beta1D_classname", _wrap_Beta1D_classname, METH_VARARGS, NULL},
	{ (char *)"Beta1D_version", _wrap_Beta1D_version, METH_VARARGS, NULL},
	{ (char *)"Beta1D_read", _wrap_Beta1D_read, METH_VARARGS, NULL},
	{ (char *)"Beta1D_swigregister", Beta1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Gamma1D", _wrap_new_Gamma1D, METH_VARARGS, NULL},
	{ (char *)"Gamma1D_clone", _wrap_Gamma1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_Gamma1D", _wrap_delete_Gamma1D, METH_VARARGS, NULL},
	{ (char *)"Gamma1D_alpha", _wrap_Gamma1D_alpha, METH_VARARGS, NULL},
	{ (char *)"Gamma1D_classId", _wrap_Gamma1D_classId, METH_VARARGS, NULL},
	{ (char *)"Gamma1D_write", _wrap_Gamma1D_write, METH_VARARGS, NULL},
	{ (char *)"Gamma1D_classname", _wrap_Gamma1D_classname, METH_VARARGS, NULL},
	{ (char *)"Gamma1D_version", _wrap_Gamma1D_version, METH_VARARGS, NULL},
	{ (char *)"Gamma1D_read", _wrap_Gamma1D_read, METH_VARARGS, NULL},
	{ (char *)"Gamma1D_swigregister", Gamma1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"Pareto1D_clone", _wrap_Pareto1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_Pareto1D", _wrap_delete_Pareto1D, METH_VARARGS, NULL},
	{ (char *)"Pareto1D_powerParameter", _wrap_Pareto1D_powerParameter, METH_VARARGS, NULL},
	{ (char *)"Pareto1D_classId", _wrap_Pareto1D_classId, METH_VARARGS, NULL},
	{ (char *)"Pareto1D_write", _wrap_Pareto1D_write, METH_VARARGS, NULL},
	{ (char *)"Pareto1D_classname", _wrap_Pareto1D_classname, METH_VARARGS, NULL},
	{ (char *)"Pareto1D_version", _wrap_Pareto1D_version, METH_VARARGS, NULL},
	{ (char *)"Pareto1D_read", _wrap_Pareto1D_read, METH_VARARGS, NULL},
	{ (char *)"Pareto1D_swigregister", Pareto1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"UniPareto1D_clone", _wrap_UniPareto1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_UniPareto1D", _wrap_delete_UniPareto1D, METH_VARARGS, NULL},
	{ (char *)"UniPareto1D_powerParameter", _wrap_UniPareto1D_powerParameter, METH_VARARGS, NULL},
	{ (char *)"UniPareto1D_classId", _wrap_UniPareto1D_classId, METH_VARARGS, NULL},
	{ (char *)"UniPareto1D_write", _wrap_UniPareto1D_write, METH_VARARGS, NULL},
	{ (char *)"UniPareto1D_classname", _wrap_UniPareto1D_classname, METH_VARARGS, NULL},
	{ (char *)"UniPareto1D_version", _wrap_UniPareto1D_version, METH_VARARGS, NULL},
	{ (char *)"UniPareto1D_read", _wrap_UniPareto1D_read, METH_VARARGS, NULL},
	{ (char *)"UniPareto1D_swigregister", UniPareto1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Huber1D", _wrap_new_Huber1D, METH_VARARGS, NULL},
	{ (char *)"Huber1D_clone", _wrap_Huber1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_Huber1D", _wrap_delete_Huber1D, METH_VARARGS, NULL},
	{ (char *)"Huber1D_tailWeight", _wrap_Huber1D_tailWeight, METH_VARARGS, NULL},
	{ (char *)"Huber1D_tailStart", _wrap_Huber1D_tailStart, METH_VARARGS, NULL},
	{ (char *)"Huber1D_classId", _wrap_Huber1D_classId, METH_VARARGS, NULL},
	{ (char *)"Huber1D_write", _wrap_Huber1D_write, METH_VARARGS, NULL},
	{ (char *)"Huber1D_classname", _wrap_Huber1D_classname, METH_VARARGS, NULL},
	{ (char *)"Huber1D_version", _wrap_Huber1D_version, METH_VARARGS, NULL},
	{ (char *)"Huber1D_read", _wrap_Huber1D_read, METH_VARARGS, NULL},
	{ (char *)"Huber1D_swigregister", Huber1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Cauchy1D", _wrap_new_Cauchy1D, METH_VARARGS, NULL},
	{ (char *)"Cauchy1D_clone", _wrap_Cauchy1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_Cauchy1D", _wrap_delete_Cauchy1D, METH_VARARGS, NULL},
	{ (char *)"Cauchy1D_classId", _wrap_Cauchy1D_classId, METH_VARARGS, NULL},
	{ (char *)"Cauchy1D_classname", _wrap_Cauchy1D_classname, METH_VARARGS, NULL},
	{ (char *)"Cauchy1D_version", _wrap_Cauchy1D_version, METH_VARARGS, NULL},
	{ (char *)"Cauchy1D_read", _wrap_Cauchy1D_read, METH_VARARGS, NULL},
	{ (char *)"Cauchy1D_swigregister", Cauchy1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LogNormal", _wrap_new_LogNormal, METH_VARARGS, NULL},
	{ (char *)"LogNormal_clone", _wrap_LogNormal_clone, METH_VARARGS, NULL},
	{ (char *)"delete_LogNormal", _wrap_delete_LogNormal, METH_VARARGS, NULL},
	{ (char *)"LogNormal_skewness", _wrap_LogNormal_skewness, METH_VARARGS, NULL},
	{ (char *)"LogNormal_classId", _wrap_LogNormal_classId, METH_VARARGS, NULL},
	{ (char *)"LogNormal_write", _wrap_LogNormal_write, METH_VARARGS, NULL},
	{ (char *)"LogNormal_classname", _wrap_LogNormal_classname, METH_VARARGS, NULL},
	{ (char *)"LogNormal_version", _wrap_LogNormal_version, METH_VARARGS, NULL},
	{ (char *)"LogNormal_read", _wrap_LogNormal_read, METH_VARARGS, NULL},
	{ (char *)"LogNormal_swigregister", LogNormal_swigregister, METH_VARARGS, NULL},
	{ (char *)"Moyal1D_clone", _wrap_Moyal1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_Moyal1D", _wrap_delete_Moyal1D, METH_VARARGS, NULL},
	{ (char *)"Moyal1D_classId", _wrap_Moyal1D_classId, METH_VARARGS, NULL},
	{ (char *)"Moyal1D_classname", _wrap_Moyal1D_classname, METH_VARARGS, NULL},
	{ (char *)"Moyal1D_version", _wrap_Moyal1D_version, METH_VARARGS, NULL},
	{ (char *)"Moyal1D_read", _wrap_Moyal1D_read, METH_VARARGS, NULL},
	{ (char *)"Moyal1D_swigregister", Moyal1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_StudentsT1D", _wrap_new_StudentsT1D, METH_VARARGS, NULL},
	{ (char *)"StudentsT1D_clone", _wrap_StudentsT1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_StudentsT1D", _wrap_delete_StudentsT1D, METH_VARARGS, NULL},
	{ (char *)"StudentsT1D_nDegreesOfFreedom", _wrap_StudentsT1D_nDegreesOfFreedom, METH_VARARGS, NULL},
	{ (char *)"StudentsT1D_classId", _wrap_StudentsT1D_classId, METH_VARARGS, NULL},
	{ (char *)"StudentsT1D_write", _wrap_StudentsT1D_write, METH_VARARGS, NULL},
	{ (char *)"StudentsT1D_classname", _wrap_StudentsT1D_classname, METH_VARARGS, NULL},
	{ (char *)"StudentsT1D_version", _wrap_StudentsT1D_version, METH_VARARGS, NULL},
	{ (char *)"StudentsT1D_read", _wrap_StudentsT1D_read, METH_VARARGS, NULL},
	{ (char *)"StudentsT1D_swigregister", StudentsT1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Tabulated1D", _wrap_new_Tabulated1D, METH_VARARGS, NULL},
	{ (char *)"Tabulated1D_clone", _wrap_Tabulated1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_Tabulated1D", _wrap_delete_Tabulated1D, METH_VARARGS, NULL},
	{ (char *)"Tabulated1D_interpolationDegree", _wrap_Tabulated1D_interpolationDegree, METH_VARARGS, NULL},
	{ (char *)"Tabulated1D_tableLength", _wrap_Tabulated1D_tableLength, METH_VARARGS, NULL},
	{ (char *)"Tabulated1D_tableData", _wrap_Tabulated1D_tableData, METH_VARARGS, NULL},
	{ (char *)"Tabulated1D_classId", _wrap_Tabulated1D_classId, METH_VARARGS, NULL},
	{ (char *)"Tabulated1D_write", _wrap_Tabulated1D_write, METH_VARARGS, NULL},
	{ (char *)"Tabulated1D_classname", _wrap_Tabulated1D_classname, METH_VARARGS, NULL},
	{ (char *)"Tabulated1D_version", _wrap_Tabulated1D_version, METH_VARARGS, NULL},
	{ (char *)"Tabulated1D_read", _wrap_Tabulated1D_read, METH_VARARGS, NULL},
	{ (char *)"Tabulated1D_swigregister", Tabulated1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_BinnedDensity1D", _wrap_new_BinnedDensity1D, METH_VARARGS, NULL},
	{ (char *)"BinnedDensity1D_clone", _wrap_BinnedDensity1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_BinnedDensity1D", _wrap_delete_BinnedDensity1D, METH_VARARGS, NULL},
	{ (char *)"BinnedDensity1D_interpolationDegree", _wrap_BinnedDensity1D_interpolationDegree, METH_VARARGS, NULL},
	{ (char *)"BinnedDensity1D_tableLength", _wrap_BinnedDensity1D_tableLength, METH_VARARGS, NULL},
	{ (char *)"BinnedDensity1D_tableData", _wrap_BinnedDensity1D_tableData, METH_VARARGS, NULL},
	{ (char *)"BinnedDensity1D_classId", _wrap_BinnedDensity1D_classId, METH_VARARGS, NULL},
	{ (char *)"BinnedDensity1D_write", _wrap_BinnedDensity1D_write, METH_VARARGS, NULL},
	{ (char *)"BinnedDensity1D_classname", _wrap_BinnedDensity1D_classname, METH_VARARGS, NULL},
	{ (char *)"BinnedDensity1D_version", _wrap_BinnedDensity1D_version, METH_VARARGS, NULL},
	{ (char *)"BinnedDensity1D_read", _wrap_BinnedDensity1D_read, METH_VARARGS, NULL},
	{ (char *)"BinnedDensity1D_swigregister", BinnedDensity1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_Tabulated1D", _wrap_new_ArchiveRecord_Tabulated1D, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_Tabulated1D", _wrap_delete_ArchiveRecord_Tabulated1D, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_Tabulated1D_swigregister", ArchiveRecord_Tabulated1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_Tabulated1D", _wrap_new_Ref_Tabulated1D, METH_VARARGS, NULL},
	{ (char *)"Ref_Tabulated1D_restore", _wrap_Ref_Tabulated1D_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_Tabulated1D_retrieve", _wrap_Ref_Tabulated1D_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_Tabulated1D_getValue", _wrap_Ref_Tabulated1D_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_Tabulated1D", _wrap_delete_Ref_Tabulated1D, METH_VARARGS, NULL},
	{ (char *)"Ref_Tabulated1D_swigregister", Ref_Tabulated1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_BinnedDensity1D", _wrap_new_ArchiveRecord_BinnedDensity1D, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_BinnedDensity1D", _wrap_delete_ArchiveRecord_BinnedDensity1D, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_BinnedDensity1D_swigregister", ArchiveRecord_BinnedDensity1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_BinnedDensity1D", _wrap_new_Ref_BinnedDensity1D, METH_VARARGS, NULL},
	{ (char *)"Ref_BinnedDensity1D_restore", _wrap_Ref_BinnedDensity1D_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_BinnedDensity1D_retrieve", _wrap_Ref_BinnedDensity1D_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_BinnedDensity1D_getValue", _wrap_Ref_BinnedDensity1D_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_BinnedDensity1D", _wrap_delete_Ref_BinnedDensity1D, METH_VARARGS, NULL},
	{ (char *)"Ref_BinnedDensity1D_swigregister", Ref_BinnedDensity1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsDistributionND", _wrap_delete_AbsDistributionND, METH_VARARGS, NULL},
	{ (char *)"AbsDistributionND_clone", _wrap_AbsDistributionND_clone, METH_VARARGS, NULL},
	{ (char *)"AbsDistributionND___eq__", _wrap_AbsDistributionND___eq__, METH_VARARGS, NULL},
	{ (char *)"AbsDistributionND___ne__", _wrap_AbsDistributionND___ne__, METH_VARARGS, NULL},
	{ (char *)"AbsDistributionND_dim", _wrap_AbsDistributionND_dim, METH_VARARGS, NULL},
	{ (char *)"AbsDistributionND_density", _wrap_AbsDistributionND_density, METH_VARARGS, NULL},
	{ (char *)"AbsDistributionND_unitMap", _wrap_AbsDistributionND_unitMap, METH_VARARGS, NULL},
	{ (char *)"AbsDistributionND_mappedByQuantiles", _wrap_AbsDistributionND_mappedByQuantiles, METH_VARARGS, NULL},
	{ (char *)"AbsDistributionND_classId", _wrap_AbsDistributionND_classId, METH_VARARGS, NULL},
	{ (char *)"AbsDistributionND_write", _wrap_AbsDistributionND_write, METH_VARARGS, NULL},
	{ (char *)"AbsDistributionND_classname", _wrap_AbsDistributionND_classname, METH_VARARGS, NULL},
	{ (char *)"AbsDistributionND_version", _wrap_AbsDistributionND_version, METH_VARARGS, NULL},
	{ (char *)"AbsDistributionND_read", _wrap_AbsDistributionND_read, METH_VARARGS, NULL},
	{ (char *)"AbsDistributionND_random", _wrap_AbsDistributionND_random, METH_VARARGS, NULL},
	{ (char *)"AbsDistributionND_generate", _wrap_AbsDistributionND_generate, METH_VARARGS, NULL},
	{ (char *)"AbsDistributionND_swigregister", AbsDistributionND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsScalableDistributionND", _wrap_delete_AbsScalableDistributionND, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistributionND_location", _wrap_AbsScalableDistributionND_location, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistributionND_scale", _wrap_AbsScalableDistributionND_scale, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistributionND_setLocation", _wrap_AbsScalableDistributionND_setLocation, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistributionND_setScale", _wrap_AbsScalableDistributionND_setScale, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistributionND_density", _wrap_AbsScalableDistributionND_density, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistributionND_unitMap", _wrap_AbsScalableDistributionND_unitMap, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistributionND_clone", _wrap_AbsScalableDistributionND_clone, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistributionND_mappedByQuantiles", _wrap_AbsScalableDistributionND_mappedByQuantiles, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistributionND_classId", _wrap_AbsScalableDistributionND_classId, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistributionND_write", _wrap_AbsScalableDistributionND_write, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistributionND_read", _wrap_AbsScalableDistributionND_read, METH_VARARGS, NULL},
	{ (char *)"AbsScalableDistributionND_swigregister", AbsScalableDistributionND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DensityFunctorND", _wrap_new_DensityFunctorND, METH_VARARGS, NULL},
	{ (char *)"delete_DensityFunctorND", _wrap_delete_DensityFunctorND, METH_VARARGS, NULL},
	{ (char *)"DensityFunctorND___call__", _wrap_DensityFunctorND___call__, METH_VARARGS, NULL},
	{ (char *)"DensityFunctorND_minDim", _wrap_DensityFunctorND_minDim, METH_VARARGS, NULL},
	{ (char *)"DensityFunctorND_swigregister", DensityFunctorND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_HomogeneousProductSymmetricBeta1D", _wrap_delete_HomogeneousProductSymmetricBeta1D, METH_VARARGS, NULL},
	{ (char *)"HomogeneousProductSymmetricBeta1D_clone", _wrap_HomogeneousProductSymmetricBeta1D_clone, METH_VARARGS, NULL},
	{ (char *)"HomogeneousProductSymmetricBeta1D_mappedByQuantiles", _wrap_HomogeneousProductSymmetricBeta1D_mappedByQuantiles, METH_VARARGS, NULL},
	{ (char *)"HomogeneousProductSymmetricBeta1D_density", _wrap_HomogeneousProductSymmetricBeta1D_density, METH_VARARGS, NULL},
	{ (char *)"HomogeneousProductSymmetricBeta1D_unitMap", _wrap_HomogeneousProductSymmetricBeta1D_unitMap, METH_VARARGS, NULL},
	{ (char *)"HomogeneousProductSymmetricBeta1D_swigregister", HomogeneousProductSymmetricBeta1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_AbsDistributionND", _wrap_new_ArchiveRecord_AbsDistributionND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_AbsDistributionND", _wrap_delete_ArchiveRecord_AbsDistributionND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_AbsDistributionND_swigregister", ArchiveRecord_AbsDistributionND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsGridInterpolatedDistribution", _wrap_delete_AbsGridInterpolatedDistribution, METH_VARARGS, NULL},
	{ (char *)"AbsGridInterpolatedDistribution_clone", _wrap_AbsGridInterpolatedDistribution_clone, METH_VARARGS, NULL},
	{ (char *)"AbsGridInterpolatedDistribution_setGridDistro", _wrap_AbsGridInterpolatedDistribution_setGridDistro, METH_VARARGS, NULL},
	{ (char *)"AbsGridInterpolatedDistribution_setLinearDistro", _wrap_AbsGridInterpolatedDistribution_setLinearDistro, METH_VARARGS, NULL},
	{ (char *)"AbsGridInterpolatedDistribution_getGridDistro", _wrap_AbsGridInterpolatedDistribution_getGridDistro, METH_VARARGS, NULL},
	{ (char *)"AbsGridInterpolatedDistribution_getLinearDistro", _wrap_AbsGridInterpolatedDistribution_getLinearDistro, METH_VARARGS, NULL},
	{ (char *)"AbsGridInterpolatedDistribution_setGridCoords", _wrap_AbsGridInterpolatedDistribution_setGridCoords, METH_VARARGS, NULL},
	{ (char *)"AbsGridInterpolatedDistribution_nAxes", _wrap_AbsGridInterpolatedDistribution_nAxes, METH_VARARGS, NULL},
	{ (char *)"AbsGridInterpolatedDistribution_nDistros", _wrap_AbsGridInterpolatedDistribution_nDistros, METH_VARARGS, NULL},
	{ (char *)"AbsGridInterpolatedDistribution_gridShape", _wrap_AbsGridInterpolatedDistribution_gridShape, METH_VARARGS, NULL},
	{ (char *)"AbsGridInterpolatedDistribution_getAxis", _wrap_AbsGridInterpolatedDistribution_getAxis, METH_VARARGS, NULL},
	{ (char *)"AbsGridInterpolatedDistribution_swigregister", AbsGridInterpolatedDistribution_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_GridRandomizer", _wrap_delete_GridRandomizer, METH_VARARGS, NULL},
	{ (char *)"GridRandomizer___eq__", _wrap_GridRandomizer___eq__, METH_VARARGS, NULL},
	{ (char *)"GridRandomizer___ne__", _wrap_GridRandomizer___ne__, METH_VARARGS, NULL},
	{ (char *)"GridRandomizer_gridData", _wrap_GridRandomizer_gridData, METH_VARARGS, NULL},
	{ (char *)"GridRandomizer_gridBoundary", _wrap_GridRandomizer_gridBoundary, METH_VARARGS, NULL},
	{ (char *)"GridRandomizer_interpolationDegree", _wrap_GridRandomizer_interpolationDegree, METH_VARARGS, NULL},
	{ (char *)"GridRandomizer_dim", _wrap_GridRandomizer_dim, METH_VARARGS, NULL},
	{ (char *)"GridRandomizer_density", _wrap_GridRandomizer_density, METH_VARARGS, NULL},
	{ (char *)"GridRandomizer_generate", _wrap_GridRandomizer_generate, METH_VARARGS, NULL},
	{ (char *)"new_GridRandomizer", _wrap_new_GridRandomizer, METH_VARARGS, NULL},
	{ (char *)"GridRandomizer_swigregister", GridRandomizer_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UGaussConvolution1D", _wrap_new_UGaussConvolution1D, METH_VARARGS, NULL},
	{ (char *)"UGaussConvolution1D_clone", _wrap_UGaussConvolution1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_UGaussConvolution1D", _wrap_delete_UGaussConvolution1D, METH_VARARGS, NULL},
	{ (char *)"UGaussConvolution1D_leftEdge", _wrap_UGaussConvolution1D_leftEdge, METH_VARARGS, NULL},
	{ (char *)"UGaussConvolution1D_uniformWidth", _wrap_UGaussConvolution1D_uniformWidth, METH_VARARGS, NULL},
	{ (char *)"UGaussConvolution1D_classId", _wrap_UGaussConvolution1D_classId, METH_VARARGS, NULL},
	{ (char *)"UGaussConvolution1D_write", _wrap_UGaussConvolution1D_write, METH_VARARGS, NULL},
	{ (char *)"UGaussConvolution1D_classname", _wrap_UGaussConvolution1D_classname, METH_VARARGS, NULL},
	{ (char *)"UGaussConvolution1D_version", _wrap_UGaussConvolution1D_version, METH_VARARGS, NULL},
	{ (char *)"UGaussConvolution1D_read", _wrap_UGaussConvolution1D_read, METH_VARARGS, NULL},
	{ (char *)"UGaussConvolution1D_swigregister", UGaussConvolution1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_JohnsonSu", _wrap_new_JohnsonSu, METH_VARARGS, NULL},
	{ (char *)"JohnsonSu_clone", _wrap_JohnsonSu_clone, METH_VARARGS, NULL},
	{ (char *)"delete_JohnsonSu", _wrap_delete_JohnsonSu, METH_VARARGS, NULL},
	{ (char *)"JohnsonSu_skewness", _wrap_JohnsonSu_skewness, METH_VARARGS, NULL},
	{ (char *)"JohnsonSu_kurtosis", _wrap_JohnsonSu_kurtosis, METH_VARARGS, NULL},
	{ (char *)"JohnsonSu_isValid", _wrap_JohnsonSu_isValid, METH_VARARGS, NULL},
	{ (char *)"JohnsonSu_getDelta", _wrap_JohnsonSu_getDelta, METH_VARARGS, NULL},
	{ (char *)"JohnsonSu_getLambda", _wrap_JohnsonSu_getLambda, METH_VARARGS, NULL},
	{ (char *)"JohnsonSu_getGamma", _wrap_JohnsonSu_getGamma, METH_VARARGS, NULL},
	{ (char *)"JohnsonSu_getXi", _wrap_JohnsonSu_getXi, METH_VARARGS, NULL},
	{ (char *)"JohnsonSu_classId", _wrap_JohnsonSu_classId, METH_VARARGS, NULL},
	{ (char *)"JohnsonSu_write", _wrap_JohnsonSu_write, METH_VARARGS, NULL},
	{ (char *)"JohnsonSu_classname", _wrap_JohnsonSu_classname, METH_VARARGS, NULL},
	{ (char *)"JohnsonSu_version", _wrap_JohnsonSu_version, METH_VARARGS, NULL},
	{ (char *)"JohnsonSu_read", _wrap_JohnsonSu_read, METH_VARARGS, NULL},
	{ (char *)"JohnsonSu_swigregister", JohnsonSu_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_JohnsonSb", _wrap_new_JohnsonSb, METH_VARARGS, NULL},
	{ (char *)"JohnsonSb_clone", _wrap_JohnsonSb_clone, METH_VARARGS, NULL},
	{ (char *)"delete_JohnsonSb", _wrap_delete_JohnsonSb, METH_VARARGS, NULL},
	{ (char *)"JohnsonSb_skewness", _wrap_JohnsonSb_skewness, METH_VARARGS, NULL},
	{ (char *)"JohnsonSb_kurtosis", _wrap_JohnsonSb_kurtosis, METH_VARARGS, NULL},
	{ (char *)"JohnsonSb_isValid", _wrap_JohnsonSb_isValid, METH_VARARGS, NULL},
	{ (char *)"JohnsonSb_getDelta", _wrap_JohnsonSb_getDelta, METH_VARARGS, NULL},
	{ (char *)"JohnsonSb_getLambda", _wrap_JohnsonSb_getLambda, METH_VARARGS, NULL},
	{ (char *)"JohnsonSb_getGamma", _wrap_JohnsonSb_getGamma, METH_VARARGS, NULL},
	{ (char *)"JohnsonSb_getXi", _wrap_JohnsonSb_getXi, METH_VARARGS, NULL},
	{ (char *)"JohnsonSb_fitParameters", _wrap_JohnsonSb_fitParameters, METH_VARARGS, NULL},
	{ (char *)"JohnsonSb_classId", _wrap_JohnsonSb_classId, METH_VARARGS, NULL},
	{ (char *)"JohnsonSb_write", _wrap_JohnsonSb_write, METH_VARARGS, NULL},
	{ (char *)"JohnsonSb_classname", _wrap_JohnsonSb_classname, METH_VARARGS, NULL},
	{ (char *)"JohnsonSb_version", _wrap_JohnsonSb_version, METH_VARARGS, NULL},
	{ (char *)"JohnsonSb_read", _wrap_JohnsonSb_read, METH_VARARGS, NULL},
	{ (char *)"JohnsonSb_swigregister", JohnsonSb_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_JohnsonSystem", _wrap_new_JohnsonSystem, METH_VARARGS, NULL},
	{ (char *)"delete_JohnsonSystem", _wrap_delete_JohnsonSystem, METH_VARARGS, NULL},
	{ (char *)"JohnsonSystem_clone", _wrap_JohnsonSystem_clone, METH_VARARGS, NULL},
	{ (char *)"JohnsonSystem_skewness", _wrap_JohnsonSystem_skewness, METH_VARARGS, NULL},
	{ (char *)"JohnsonSystem_kurtosis", _wrap_JohnsonSystem_kurtosis, METH_VARARGS, NULL},
	{ (char *)"JohnsonSystem_curveType", _wrap_JohnsonSystem_curveType, METH_VARARGS, NULL},
	{ (char *)"JohnsonSystem_isValid", _wrap_JohnsonSystem_isValid, METH_VARARGS, NULL},
	{ (char *)"JohnsonSystem_select", _wrap_JohnsonSystem_select, METH_VARARGS, NULL},
	{ (char *)"JohnsonSystem_classId", _wrap_JohnsonSystem_classId, METH_VARARGS, NULL},
	{ (char *)"JohnsonSystem_write", _wrap_JohnsonSystem_write, METH_VARARGS, NULL},
	{ (char *)"JohnsonSystem_classname", _wrap_JohnsonSystem_classname, METH_VARARGS, NULL},
	{ (char *)"JohnsonSystem_version", _wrap_JohnsonSystem_version, METH_VARARGS, NULL},
	{ (char *)"JohnsonSystem_read", _wrap_JohnsonSystem_read, METH_VARARGS, NULL},
	{ (char *)"JohnsonSystem_swigregister", JohnsonSystem_swigregister, METH_VARARGS, NULL},
	{ (char *)"parseEigenMethod", _wrap_parseEigenMethod, METH_VARARGS, NULL},
	{ (char *)"eigenMethodName", _wrap_eigenMethodName, METH_VARARGS, NULL},
	{ (char *)"validEigenMethodNames", _wrap_validEigenMethodNames, METH_VARARGS, NULL},
	{ (char *)"parseSvdMethod", _wrap_parseSvdMethod, METH_VARARGS, NULL},
	{ (char *)"svdMethodName", _wrap_svdMethodName, METH_VARARGS, NULL},
	{ (char *)"validSvdMethodNames", _wrap_validSvdMethodNames, METH_VARARGS, NULL},
	{ (char *)"delete_FloatMatrix", _wrap_delete_FloatMatrix, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_tagAsDiagonal", _wrap_FloatMatrix_tagAsDiagonal, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_nRows", _wrap_FloatMatrix_nRows, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_nColumns", _wrap_FloatMatrix_nColumns, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_length", _wrap_FloatMatrix_length, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_data", _wrap_FloatMatrix_data, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_isSquare", _wrap_FloatMatrix_isSquare, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_isSymmetric", _wrap_FloatMatrix_isSymmetric, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_isAntiSymmetric", _wrap_FloatMatrix_isAntiSymmetric, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_isDiagonal", _wrap_FloatMatrix_isDiagonal, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_uninitialize", _wrap_FloatMatrix_uninitialize, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_isCompatible", _wrap_FloatMatrix_isCompatible, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_resize", _wrap_FloatMatrix_resize, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_zeroOut", _wrap_FloatMatrix_zeroOut, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_clearMainDiagonal", _wrap_FloatMatrix_clearMainDiagonal, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_makeDiagonal", _wrap_FloatMatrix_makeDiagonal, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_constFill", _wrap_FloatMatrix_constFill, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_Tthis", _wrap_FloatMatrix_Tthis, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix___eq__", _wrap_FloatMatrix___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix___ne__", _wrap_FloatMatrix___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_set", _wrap_FloatMatrix_set, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix___call__", _wrap_FloatMatrix___call__, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_rowSum", _wrap_FloatMatrix_rowSum, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_columnSum", _wrap_FloatMatrix_columnSum, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_removeRowAndColumn", _wrap_FloatMatrix_removeRowAndColumn, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_nonZeros", _wrap_FloatMatrix_nonZeros, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_coarseSum", _wrap_FloatMatrix_coarseSum, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_coarseAverage", _wrap_FloatMatrix_coarseAverage, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix___pos__", _wrap_FloatMatrix___pos__, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix___neg__", _wrap_FloatMatrix___neg__, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix___mul__", _wrap_FloatMatrix___mul__, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix___truediv__", _wrap_FloatMatrix___truediv__, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix___add__", _wrap_FloatMatrix___add__, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix___sub__", _wrap_FloatMatrix___sub__, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_hadamardProduct", _wrap_FloatMatrix_hadamardProduct, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_hadamardRatio", _wrap_FloatMatrix_hadamardRatio, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_times", _wrap_FloatMatrix_times, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_over", _wrap_FloatMatrix_over, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_plus", _wrap_FloatMatrix_plus, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_minus", _wrap_FloatMatrix_minus, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix___imul__", _wrap_FloatMatrix___imul__, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix___itruediv__", _wrap_FloatMatrix___itruediv__, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix___iadd__", _wrap_FloatMatrix___iadd__, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix___isub__", _wrap_FloatMatrix___isub__, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_bilinearT", _wrap_FloatMatrix_bilinearT, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_solveLinearSystems", _wrap_FloatMatrix_solveLinearSystems, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_underdeterminedLinearSystem", _wrap_FloatMatrix_underdeterminedLinearSystem, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_linearLeastSquares", _wrap_FloatMatrix_linearLeastSquares, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_constrainedLeastSquares", _wrap_FloatMatrix_constrainedLeastSquares, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_weightedLeastSquares", _wrap_FloatMatrix_weightedLeastSquares, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_T", _wrap_FloatMatrix_T, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_TtimesThis", _wrap_FloatMatrix_TtimesThis, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_timesT", _wrap_FloatMatrix_timesT, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_Ttimes", _wrap_FloatMatrix_Ttimes, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_directSum", _wrap_FloatMatrix_directSum, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_symmetrize", _wrap_FloatMatrix_symmetrize, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_antiSymmetrize", _wrap_FloatMatrix_antiSymmetrize, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_outer", _wrap_FloatMatrix_outer, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_maxAbsValue", _wrap_FloatMatrix_maxAbsValue, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_frobeniusNorm", _wrap_FloatMatrix_frobeniusNorm, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_tr", _wrap_FloatMatrix_tr, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_sp", _wrap_FloatMatrix_sp, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_productTr", _wrap_FloatMatrix_productTr, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_productSp", _wrap_FloatMatrix_productSp, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_det", _wrap_FloatMatrix_det, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_symPDInv", _wrap_FloatMatrix_symPDInv, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_symPDEigenInv", _wrap_FloatMatrix_symPDEigenInv, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_symInv", _wrap_FloatMatrix_symInv, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_inv", _wrap_FloatMatrix_inv, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_tdSymEigen", _wrap_FloatMatrix_tdSymEigen, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_svd", _wrap_FloatMatrix_svd, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_symPSDefEffectiveRank", _wrap_FloatMatrix_symPSDefEffectiveRank, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_pow", _wrap_FloatMatrix_pow, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_covarToCorr", _wrap_FloatMatrix_covarToCorr, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_classId", _wrap_FloatMatrix_classId, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_write", _wrap_FloatMatrix_write, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_classname", _wrap_FloatMatrix_classname, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_version", _wrap_FloatMatrix_version, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_restore", _wrap_FloatMatrix_restore, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_timesVector", _wrap_FloatMatrix_timesVector, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_rowMultiply", _wrap_FloatMatrix_rowMultiply, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_bilinear", _wrap_FloatMatrix_bilinear, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_solveLinearSystem", _wrap_FloatMatrix_solveLinearSystem, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_symEigenValues", _wrap_FloatMatrix_symEigenValues, METH_VARARGS, NULL},
	{ (char *)"new_FloatMatrix", _wrap_new_FloatMatrix, METH_VARARGS, NULL},
	{ (char *)"FloatMatrix_swigregister", FloatMatrix_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleMatrix", _wrap_delete_DoubleMatrix, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_tagAsDiagonal", _wrap_DoubleMatrix_tagAsDiagonal, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_nRows", _wrap_DoubleMatrix_nRows, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_nColumns", _wrap_DoubleMatrix_nColumns, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_length", _wrap_DoubleMatrix_length, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_data", _wrap_DoubleMatrix_data, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_isSquare", _wrap_DoubleMatrix_isSquare, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_isSymmetric", _wrap_DoubleMatrix_isSymmetric, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_isAntiSymmetric", _wrap_DoubleMatrix_isAntiSymmetric, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_isDiagonal", _wrap_DoubleMatrix_isDiagonal, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_uninitialize", _wrap_DoubleMatrix_uninitialize, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_isCompatible", _wrap_DoubleMatrix_isCompatible, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_resize", _wrap_DoubleMatrix_resize, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_zeroOut", _wrap_DoubleMatrix_zeroOut, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_clearMainDiagonal", _wrap_DoubleMatrix_clearMainDiagonal, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_makeDiagonal", _wrap_DoubleMatrix_makeDiagonal, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_constFill", _wrap_DoubleMatrix_constFill, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_Tthis", _wrap_DoubleMatrix_Tthis, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix___eq__", _wrap_DoubleMatrix___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix___ne__", _wrap_DoubleMatrix___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_set", _wrap_DoubleMatrix_set, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix___call__", _wrap_DoubleMatrix___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_rowSum", _wrap_DoubleMatrix_rowSum, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_columnSum", _wrap_DoubleMatrix_columnSum, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_removeRowAndColumn", _wrap_DoubleMatrix_removeRowAndColumn, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_nonZeros", _wrap_DoubleMatrix_nonZeros, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_coarseSum", _wrap_DoubleMatrix_coarseSum, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_coarseAverage", _wrap_DoubleMatrix_coarseAverage, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix___pos__", _wrap_DoubleMatrix___pos__, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix___neg__", _wrap_DoubleMatrix___neg__, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix___mul__", _wrap_DoubleMatrix___mul__, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix___truediv__", _wrap_DoubleMatrix___truediv__, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix___add__", _wrap_DoubleMatrix___add__, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix___sub__", _wrap_DoubleMatrix___sub__, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_hadamardProduct", _wrap_DoubleMatrix_hadamardProduct, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_hadamardRatio", _wrap_DoubleMatrix_hadamardRatio, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_times", _wrap_DoubleMatrix_times, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_over", _wrap_DoubleMatrix_over, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_plus", _wrap_DoubleMatrix_plus, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_minus", _wrap_DoubleMatrix_minus, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix___imul__", _wrap_DoubleMatrix___imul__, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix___itruediv__", _wrap_DoubleMatrix___itruediv__, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix___iadd__", _wrap_DoubleMatrix___iadd__, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix___isub__", _wrap_DoubleMatrix___isub__, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_bilinearT", _wrap_DoubleMatrix_bilinearT, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_solveLinearSystems", _wrap_DoubleMatrix_solveLinearSystems, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_underdeterminedLinearSystem", _wrap_DoubleMatrix_underdeterminedLinearSystem, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_linearLeastSquares", _wrap_DoubleMatrix_linearLeastSquares, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_constrainedLeastSquares", _wrap_DoubleMatrix_constrainedLeastSquares, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_weightedLeastSquares", _wrap_DoubleMatrix_weightedLeastSquares, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_T", _wrap_DoubleMatrix_T, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_TtimesThis", _wrap_DoubleMatrix_TtimesThis, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_timesT", _wrap_DoubleMatrix_timesT, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_Ttimes", _wrap_DoubleMatrix_Ttimes, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_directSum", _wrap_DoubleMatrix_directSum, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_symmetrize", _wrap_DoubleMatrix_symmetrize, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_antiSymmetrize", _wrap_DoubleMatrix_antiSymmetrize, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_outer", _wrap_DoubleMatrix_outer, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_maxAbsValue", _wrap_DoubleMatrix_maxAbsValue, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_frobeniusNorm", _wrap_DoubleMatrix_frobeniusNorm, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_tr", _wrap_DoubleMatrix_tr, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_sp", _wrap_DoubleMatrix_sp, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_productTr", _wrap_DoubleMatrix_productTr, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_productSp", _wrap_DoubleMatrix_productSp, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_det", _wrap_DoubleMatrix_det, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_symPDInv", _wrap_DoubleMatrix_symPDInv, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_symPDEigenInv", _wrap_DoubleMatrix_symPDEigenInv, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_symInv", _wrap_DoubleMatrix_symInv, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_inv", _wrap_DoubleMatrix_inv, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_tdSymEigen", _wrap_DoubleMatrix_tdSymEigen, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_svd", _wrap_DoubleMatrix_svd, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_symPSDefEffectiveRank", _wrap_DoubleMatrix_symPSDefEffectiveRank, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_pow", _wrap_DoubleMatrix_pow, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_covarToCorr", _wrap_DoubleMatrix_covarToCorr, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_classId", _wrap_DoubleMatrix_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_write", _wrap_DoubleMatrix_write, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_classname", _wrap_DoubleMatrix_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_version", _wrap_DoubleMatrix_version, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_restore", _wrap_DoubleMatrix_restore, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_timesVector", _wrap_DoubleMatrix_timesVector, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_rowMultiply", _wrap_DoubleMatrix_rowMultiply, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_bilinear", _wrap_DoubleMatrix_bilinear, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_solveLinearSystem", _wrap_DoubleMatrix_solveLinearSystem, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_symEigenValues", _wrap_DoubleMatrix_symEigenValues, METH_VARARGS, NULL},
	{ (char *)"new_DoubleMatrix", _wrap_new_DoubleMatrix, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_symEigenSystem", _wrap_DoubleMatrix_symEigenSystem, METH_VARARGS, NULL},
	{ (char *)"new_Matrix", _wrap_new_Matrix, METH_VARARGS, NULL},
	{ (char *)"DoubleMatrix_swigregister", DoubleMatrix_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_LDoubleMatrix", _wrap_delete_LDoubleMatrix, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_tagAsDiagonal", _wrap_LDoubleMatrix_tagAsDiagonal, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_nRows", _wrap_LDoubleMatrix_nRows, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_nColumns", _wrap_LDoubleMatrix_nColumns, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_length", _wrap_LDoubleMatrix_length, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_data", _wrap_LDoubleMatrix_data, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_isSquare", _wrap_LDoubleMatrix_isSquare, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_isSymmetric", _wrap_LDoubleMatrix_isSymmetric, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_isAntiSymmetric", _wrap_LDoubleMatrix_isAntiSymmetric, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_isDiagonal", _wrap_LDoubleMatrix_isDiagonal, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_uninitialize", _wrap_LDoubleMatrix_uninitialize, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_isCompatible", _wrap_LDoubleMatrix_isCompatible, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_resize", _wrap_LDoubleMatrix_resize, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_zeroOut", _wrap_LDoubleMatrix_zeroOut, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_clearMainDiagonal", _wrap_LDoubleMatrix_clearMainDiagonal, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_makeDiagonal", _wrap_LDoubleMatrix_makeDiagonal, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_constFill", _wrap_LDoubleMatrix_constFill, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_Tthis", _wrap_LDoubleMatrix_Tthis, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix___eq__", _wrap_LDoubleMatrix___eq__, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix___ne__", _wrap_LDoubleMatrix___ne__, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_set", _wrap_LDoubleMatrix_set, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix___call__", _wrap_LDoubleMatrix___call__, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_rowSum", _wrap_LDoubleMatrix_rowSum, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_columnSum", _wrap_LDoubleMatrix_columnSum, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_removeRowAndColumn", _wrap_LDoubleMatrix_removeRowAndColumn, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_nonZeros", _wrap_LDoubleMatrix_nonZeros, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_coarseSum", _wrap_LDoubleMatrix_coarseSum, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_coarseAverage", _wrap_LDoubleMatrix_coarseAverage, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix___pos__", _wrap_LDoubleMatrix___pos__, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix___neg__", _wrap_LDoubleMatrix___neg__, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix___mul__", _wrap_LDoubleMatrix___mul__, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix___truediv__", _wrap_LDoubleMatrix___truediv__, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix___add__", _wrap_LDoubleMatrix___add__, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix___sub__", _wrap_LDoubleMatrix___sub__, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_hadamardProduct", _wrap_LDoubleMatrix_hadamardProduct, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_hadamardRatio", _wrap_LDoubleMatrix_hadamardRatio, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_times", _wrap_LDoubleMatrix_times, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_over", _wrap_LDoubleMatrix_over, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_plus", _wrap_LDoubleMatrix_plus, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_minus", _wrap_LDoubleMatrix_minus, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix___imul__", _wrap_LDoubleMatrix___imul__, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix___itruediv__", _wrap_LDoubleMatrix___itruediv__, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix___iadd__", _wrap_LDoubleMatrix___iadd__, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix___isub__", _wrap_LDoubleMatrix___isub__, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_bilinearT", _wrap_LDoubleMatrix_bilinearT, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_solveLinearSystems", _wrap_LDoubleMatrix_solveLinearSystems, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_underdeterminedLinearSystem", _wrap_LDoubleMatrix_underdeterminedLinearSystem, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_linearLeastSquares", _wrap_LDoubleMatrix_linearLeastSquares, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_constrainedLeastSquares", _wrap_LDoubleMatrix_constrainedLeastSquares, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_weightedLeastSquares", _wrap_LDoubleMatrix_weightedLeastSquares, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_T", _wrap_LDoubleMatrix_T, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_TtimesThis", _wrap_LDoubleMatrix_TtimesThis, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_timesT", _wrap_LDoubleMatrix_timesT, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_Ttimes", _wrap_LDoubleMatrix_Ttimes, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_directSum", _wrap_LDoubleMatrix_directSum, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_symmetrize", _wrap_LDoubleMatrix_symmetrize, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_antiSymmetrize", _wrap_LDoubleMatrix_antiSymmetrize, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_outer", _wrap_LDoubleMatrix_outer, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_maxAbsValue", _wrap_LDoubleMatrix_maxAbsValue, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_frobeniusNorm", _wrap_LDoubleMatrix_frobeniusNorm, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_tr", _wrap_LDoubleMatrix_tr, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_sp", _wrap_LDoubleMatrix_sp, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_productTr", _wrap_LDoubleMatrix_productTr, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_productSp", _wrap_LDoubleMatrix_productSp, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_det", _wrap_LDoubleMatrix_det, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_symPDInv", _wrap_LDoubleMatrix_symPDInv, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_symPDEigenInv", _wrap_LDoubleMatrix_symPDEigenInv, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_symInv", _wrap_LDoubleMatrix_symInv, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_inv", _wrap_LDoubleMatrix_inv, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_tdSymEigen", _wrap_LDoubleMatrix_tdSymEigen, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_svd", _wrap_LDoubleMatrix_svd, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_symPSDefEffectiveRank", _wrap_LDoubleMatrix_symPSDefEffectiveRank, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_pow", _wrap_LDoubleMatrix_pow, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_covarToCorr", _wrap_LDoubleMatrix_covarToCorr, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_classId", _wrap_LDoubleMatrix_classId, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_write", _wrap_LDoubleMatrix_write, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_classname", _wrap_LDoubleMatrix_classname, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_version", _wrap_LDoubleMatrix_version, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_restore", _wrap_LDoubleMatrix_restore, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_timesVector", _wrap_LDoubleMatrix_timesVector, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_rowMultiply", _wrap_LDoubleMatrix_rowMultiply, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_bilinear", _wrap_LDoubleMatrix_bilinear, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_solveLinearSystem", _wrap_LDoubleMatrix_solveLinearSystem, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_symEigenValues", _wrap_LDoubleMatrix_symEigenValues, METH_VARARGS, NULL},
	{ (char *)"new_LDoubleMatrix", _wrap_new_LDoubleMatrix, METH_VARARGS, NULL},
	{ (char *)"LDoubleMatrix_swigregister", LDoubleMatrix_swigregister, METH_VARARGS, NULL},
	{ (char *)"diag", _wrap_diag, METH_VARARGS, NULL},
	{ (char *)"new_Eigensystem", _wrap_new_Eigensystem, METH_VARARGS, NULL},
	{ (char *)"Eigensystem_first_set", _wrap_Eigensystem_first_set, METH_VARARGS, NULL},
	{ (char *)"Eigensystem_first_get", _wrap_Eigensystem_first_get, METH_VARARGS, NULL},
	{ (char *)"Eigensystem_second_set", _wrap_Eigensystem_second_set, METH_VARARGS, NULL},
	{ (char *)"Eigensystem_second_get", _wrap_Eigensystem_second_get, METH_VARARGS, NULL},
	{ (char *)"delete_Eigensystem", _wrap_delete_Eigensystem, METH_VARARGS, NULL},
	{ (char *)"Eigensystem_swigregister", Eigensystem_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_FloatMatrix", _wrap_new_ArchiveRecord_FloatMatrix, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_FloatMatrix", _wrap_delete_ArchiveRecord_FloatMatrix, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_FloatMatrix_swigregister", ArchiveRecord_FloatMatrix_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_FloatMatrix", _wrap_new_Ref_FloatMatrix, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatMatrix_restore", _wrap_Ref_FloatMatrix_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatMatrix_retrieve", _wrap_Ref_FloatMatrix_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatMatrix_getValue", _wrap_Ref_FloatMatrix_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_FloatMatrix", _wrap_delete_Ref_FloatMatrix, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatMatrix_swigregister", Ref_FloatMatrix_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DoubleMatrix", _wrap_new_ArchiveRecord_DoubleMatrix, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DoubleMatrix", _wrap_delete_ArchiveRecord_DoubleMatrix, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DoubleMatrix_swigregister", ArchiveRecord_DoubleMatrix_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DoubleMatrix", _wrap_new_Ref_DoubleMatrix, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleMatrix_restore", _wrap_Ref_DoubleMatrix_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleMatrix_retrieve", _wrap_Ref_DoubleMatrix_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleMatrix_getValue", _wrap_Ref_DoubleMatrix_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DoubleMatrix", _wrap_delete_Ref_DoubleMatrix, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleMatrix_swigregister", Ref_DoubleMatrix_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_LDoubleMatrix", _wrap_new_ArchiveRecord_LDoubleMatrix, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_LDoubleMatrix", _wrap_delete_ArchiveRecord_LDoubleMatrix, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_LDoubleMatrix_swigregister", ArchiveRecord_LDoubleMatrix_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_LDoubleMatrix", _wrap_new_Ref_LDoubleMatrix, METH_VARARGS, NULL},
	{ (char *)"Ref_LDoubleMatrix_restore", _wrap_Ref_LDoubleMatrix_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_LDoubleMatrix_retrieve", _wrap_Ref_LDoubleMatrix_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_LDoubleMatrix_getValue", _wrap_Ref_LDoubleMatrix_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_LDoubleMatrix", _wrap_delete_Ref_LDoubleMatrix, METH_VARARGS, NULL},
	{ (char *)"Ref_LDoubleMatrix_swigregister", Ref_LDoubleMatrix_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ProductDistributionND", _wrap_new_ProductDistributionND, METH_VARARGS, NULL},
	{ (char *)"delete_ProductDistributionND", _wrap_delete_ProductDistributionND, METH_VARARGS, NULL},
	{ (char *)"ProductDistributionND_clone", _wrap_ProductDistributionND_clone, METH_VARARGS, NULL},
	{ (char *)"ProductDistributionND_density", _wrap_ProductDistributionND_density, METH_VARARGS, NULL},
	{ (char *)"ProductDistributionND_unitMap", _wrap_ProductDistributionND_unitMap, METH_VARARGS, NULL},
	{ (char *)"ProductDistributionND_mappedByQuantiles", _wrap_ProductDistributionND_mappedByQuantiles, METH_VARARGS, NULL},
	{ (char *)"ProductDistributionND_isScalable", _wrap_ProductDistributionND_isScalable, METH_VARARGS, NULL},
	{ (char *)"ProductDistributionND_getMarginal", _wrap_ProductDistributionND_getMarginal, METH_VARARGS, NULL},
	{ (char *)"ProductDistributionND_classId", _wrap_ProductDistributionND_classId, METH_VARARGS, NULL},
	{ (char *)"ProductDistributionND_write", _wrap_ProductDistributionND_write, METH_VARARGS, NULL},
	{ (char *)"ProductDistributionND_classname", _wrap_ProductDistributionND_classname, METH_VARARGS, NULL},
	{ (char *)"ProductDistributionND_version", _wrap_ProductDistributionND_version, METH_VARARGS, NULL},
	{ (char *)"ProductDistributionND_read", _wrap_ProductDistributionND_read, METH_VARARGS, NULL},
	{ (char *)"ProductDistributionND_swigregister", ProductDistributionND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UniformND", _wrap_new_UniformND, METH_VARARGS, NULL},
	{ (char *)"delete_UniformND", _wrap_delete_UniformND, METH_VARARGS, NULL},
	{ (char *)"UniformND_clone", _wrap_UniformND_clone, METH_VARARGS, NULL},
	{ (char *)"UniformND_mappedByQuantiles", _wrap_UniformND_mappedByQuantiles, METH_VARARGS, NULL},
	{ (char *)"UniformND_classId", _wrap_UniformND_classId, METH_VARARGS, NULL},
	{ (char *)"UniformND_write", _wrap_UniformND_write, METH_VARARGS, NULL},
	{ (char *)"UniformND_classname", _wrap_UniformND_classname, METH_VARARGS, NULL},
	{ (char *)"UniformND_version", _wrap_UniformND_version, METH_VARARGS, NULL},
	{ (char *)"UniformND_read", _wrap_UniformND_read, METH_VARARGS, NULL},
	{ (char *)"UniformND_swigregister", UniformND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ScalableSymmetricBetaND", _wrap_new_ScalableSymmetricBetaND, METH_VARARGS, NULL},
	{ (char *)"ScalableSymmetricBetaND_clone", _wrap_ScalableSymmetricBetaND_clone, METH_VARARGS, NULL},
	{ (char *)"delete_ScalableSymmetricBetaND", _wrap_delete_ScalableSymmetricBetaND, METH_VARARGS, NULL},
	{ (char *)"ScalableSymmetricBetaND_mappedByQuantiles", _wrap_ScalableSymmetricBetaND_mappedByQuantiles, METH_VARARGS, NULL},
	{ (char *)"ScalableSymmetricBetaND_power", _wrap_ScalableSymmetricBetaND_power, METH_VARARGS, NULL},
	{ (char *)"ScalableSymmetricBetaND_classId", _wrap_ScalableSymmetricBetaND_classId, METH_VARARGS, NULL},
	{ (char *)"ScalableSymmetricBetaND_classname", _wrap_ScalableSymmetricBetaND_classname, METH_VARARGS, NULL},
	{ (char *)"ScalableSymmetricBetaND_version", _wrap_ScalableSymmetricBetaND_version, METH_VARARGS, NULL},
	{ (char *)"ScalableSymmetricBetaND_swigregister", ScalableSymmetricBetaND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ScalableHuberND", _wrap_new_ScalableHuberND, METH_VARARGS, NULL},
	{ (char *)"ScalableHuberND_clone", _wrap_ScalableHuberND_clone, METH_VARARGS, NULL},
	{ (char *)"delete_ScalableHuberND", _wrap_delete_ScalableHuberND, METH_VARARGS, NULL},
	{ (char *)"ScalableHuberND_mappedByQuantiles", _wrap_ScalableHuberND_mappedByQuantiles, METH_VARARGS, NULL},
	{ (char *)"ScalableHuberND_tailWeight", _wrap_ScalableHuberND_tailWeight, METH_VARARGS, NULL},
	{ (char *)"ScalableHuberND_transition", _wrap_ScalableHuberND_transition, METH_VARARGS, NULL},
	{ (char *)"ScalableHuberND_classId", _wrap_ScalableHuberND_classId, METH_VARARGS, NULL},
	{ (char *)"ScalableHuberND_classname", _wrap_ScalableHuberND_classname, METH_VARARGS, NULL},
	{ (char *)"ScalableHuberND_version", _wrap_ScalableHuberND_version, METH_VARARGS, NULL},
	{ (char *)"ScalableHuberND_swigregister", ScalableHuberND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ProductSymmetricBetaND", _wrap_new_ProductSymmetricBetaND, METH_VARARGS, NULL},
	{ (char *)"ProductSymmetricBetaND_clone", _wrap_ProductSymmetricBetaND_clone, METH_VARARGS, NULL},
	{ (char *)"delete_ProductSymmetricBetaND", _wrap_delete_ProductSymmetricBetaND, METH_VARARGS, NULL},
	{ (char *)"ProductSymmetricBetaND_power", _wrap_ProductSymmetricBetaND_power, METH_VARARGS, NULL},
	{ (char *)"ProductSymmetricBetaND_classId", _wrap_ProductSymmetricBetaND_classId, METH_VARARGS, NULL},
	{ (char *)"ProductSymmetricBetaND_classname", _wrap_ProductSymmetricBetaND_classname, METH_VARARGS, NULL},
	{ (char *)"ProductSymmetricBetaND_version", _wrap_ProductSymmetricBetaND_version, METH_VARARGS, NULL},
	{ (char *)"ProductSymmetricBetaND_swigregister", ProductSymmetricBetaND_swigregister, METH_VARARGS, NULL},
	{ (char *)"RadialProfileND_clone", _wrap_RadialProfileND_clone, METH_VARARGS, NULL},
	{ (char *)"delete_RadialProfileND", _wrap_delete_RadialProfileND, METH_VARARGS, NULL},
	{ (char *)"RadialProfileND_mappedByQuantiles", _wrap_RadialProfileND_mappedByQuantiles, METH_VARARGS, NULL},
	{ (char *)"RadialProfileND_interpolationDegree", _wrap_RadialProfileND_interpolationDegree, METH_VARARGS, NULL},
	{ (char *)"RadialProfileND_profileLength", _wrap_RadialProfileND_profileLength, METH_VARARGS, NULL},
	{ (char *)"RadialProfileND_profileData", _wrap_RadialProfileND_profileData, METH_VARARGS, NULL},
	{ (char *)"RadialProfileND_classId", _wrap_RadialProfileND_classId, METH_VARARGS, NULL},
	{ (char *)"RadialProfileND_write", _wrap_RadialProfileND_write, METH_VARARGS, NULL},
	{ (char *)"RadialProfileND_classname", _wrap_RadialProfileND_classname, METH_VARARGS, NULL},
	{ (char *)"RadialProfileND_version", _wrap_RadialProfileND_version, METH_VARARGS, NULL},
	{ (char *)"RadialProfileND_read", _wrap_RadialProfileND_read, METH_VARARGS, NULL},
	{ (char *)"new_RadialProfileND", _wrap_new_RadialProfileND, METH_VARARGS, NULL},
	{ (char *)"RadialProfileND_swigregister", RadialProfileND_swigregister, METH_VARARGS, NULL},
	{ (char *)"BinnedDensityND_clone", _wrap_BinnedDensityND_clone, METH_VARARGS, NULL},
	{ (char *)"delete_BinnedDensityND", _wrap_delete_BinnedDensityND, METH_VARARGS, NULL},
	{ (char *)"BinnedDensityND_mappedByQuantiles", _wrap_BinnedDensityND_mappedByQuantiles, METH_VARARGS, NULL},
	{ (char *)"BinnedDensityND_gridData", _wrap_BinnedDensityND_gridData, METH_VARARGS, NULL},
	{ (char *)"BinnedDensityND_interpolationDegree", _wrap_BinnedDensityND_interpolationDegree, METH_VARARGS, NULL},
	{ (char *)"BinnedDensityND_classId", _wrap_BinnedDensityND_classId, METH_VARARGS, NULL},
	{ (char *)"BinnedDensityND_write", _wrap_BinnedDensityND_write, METH_VARARGS, NULL},
	{ (char *)"BinnedDensityND_classname", _wrap_BinnedDensityND_classname, METH_VARARGS, NULL},
	{ (char *)"BinnedDensityND_version", _wrap_BinnedDensityND_version, METH_VARARGS, NULL},
	{ (char *)"BinnedDensityND_read", _wrap_BinnedDensityND_read, METH_VARARGS, NULL},
	{ (char *)"BinnedDensityND_swigregister", BinnedDensityND_swigregister, METH_VARARGS, NULL},
	{ (char *)"histoCovariance", _wrap_histoCovariance, METH_VARARGS, NULL},
	{ (char *)"histoMean", _wrap_histoMean, METH_VARARGS, NULL},
	{ (char *)"histoQuantiles", _wrap_histoQuantiles, METH_VARARGS, NULL},
	{ (char *)"histoDensity1D", _wrap_histoDensity1D, METH_VARARGS, NULL},
	{ (char *)"histoDensityND", _wrap_histoDensityND, METH_VARARGS, NULL},
	{ (char *)"new_TruncatedDistribution1D", _wrap_new_TruncatedDistribution1D, METH_VARARGS, NULL},
	{ (char *)"TruncatedDistribution1D_clone", _wrap_TruncatedDistribution1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_TruncatedDistribution1D", _wrap_delete_TruncatedDistribution1D, METH_VARARGS, NULL},
	{ (char *)"TruncatedDistribution1D_density", _wrap_TruncatedDistribution1D_density, METH_VARARGS, NULL},
	{ (char *)"TruncatedDistribution1D_cdf", _wrap_TruncatedDistribution1D_cdf, METH_VARARGS, NULL},
	{ (char *)"TruncatedDistribution1D_exceedance", _wrap_TruncatedDistribution1D_exceedance, METH_VARARGS, NULL},
	{ (char *)"TruncatedDistribution1D_quantile", _wrap_TruncatedDistribution1D_quantile, METH_VARARGS, NULL},
	{ (char *)"TruncatedDistribution1D_classId", _wrap_TruncatedDistribution1D_classId, METH_VARARGS, NULL},
	{ (char *)"TruncatedDistribution1D_write", _wrap_TruncatedDistribution1D_write, METH_VARARGS, NULL},
	{ (char *)"TruncatedDistribution1D_classname", _wrap_TruncatedDistribution1D_classname, METH_VARARGS, NULL},
	{ (char *)"TruncatedDistribution1D_version", _wrap_TruncatedDistribution1D_version, METH_VARARGS, NULL},
	{ (char *)"TruncatedDistribution1D_read", _wrap_TruncatedDistribution1D_read, METH_VARARGS, NULL},
	{ (char *)"TruncatedDistribution1D_swigregister", TruncatedDistribution1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharInMemoryNtuple", _wrap_new_UCharInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_UCharInMemoryNtuple", _wrap_delete_UCharInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"UCharInMemoryNtuple_nRows", _wrap_UCharInMemoryNtuple_nRows, METH_VARARGS, NULL},
	{ (char *)"UCharInMemoryNtuple_fill", _wrap_UCharInMemoryNtuple_fill, METH_VARARGS, NULL},
	{ (char *)"UCharInMemoryNtuple___call__", _wrap_UCharInMemoryNtuple___call__, METH_VARARGS, NULL},
	{ (char *)"UCharInMemoryNtuple_at", _wrap_UCharInMemoryNtuple_at, METH_VARARGS, NULL},
	{ (char *)"UCharInMemoryNtuple_clear", _wrap_UCharInMemoryNtuple_clear, METH_VARARGS, NULL},
	{ (char *)"UCharInMemoryNtuple_rowContents", _wrap_UCharInMemoryNtuple_rowContents, METH_VARARGS, NULL},
	{ (char *)"UCharInMemoryNtuple_columnContents", _wrap_UCharInMemoryNtuple_columnContents, METH_VARARGS, NULL},
	{ (char *)"UCharInMemoryNtuple_classId", _wrap_UCharInMemoryNtuple_classId, METH_VARARGS, NULL},
	{ (char *)"UCharInMemoryNtuple_write", _wrap_UCharInMemoryNtuple_write, METH_VARARGS, NULL},
	{ (char *)"UCharInMemoryNtuple_classname", _wrap_UCharInMemoryNtuple_classname, METH_VARARGS, NULL},
	{ (char *)"UCharInMemoryNtuple_version", _wrap_UCharInMemoryNtuple_version, METH_VARARGS, NULL},
	{ (char *)"UCharInMemoryNtuple_read", _wrap_UCharInMemoryNtuple_read, METH_VARARGS, NULL},
	{ (char *)"UCharInMemoryNtuple_swigregister", UCharInMemoryNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_UCharInMemoryNtuple", _wrap_new_ArchiveRecord_UCharInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_UCharInMemoryNtuple", _wrap_delete_ArchiveRecord_UCharInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_UCharInMemoryNtuple_swigregister", ArchiveRecord_UCharInMemoryNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_UCharInMemoryNtuple", _wrap_new_Ref_UCharInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharInMemoryNtuple_restore", _wrap_Ref_UCharInMemoryNtuple_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharInMemoryNtuple_retrieve", _wrap_Ref_UCharInMemoryNtuple_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharInMemoryNtuple_getValue", _wrap_Ref_UCharInMemoryNtuple_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_UCharInMemoryNtuple", _wrap_delete_Ref_UCharInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharInMemoryNtuple_swigregister", Ref_UCharInMemoryNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntInMemoryNtuple", _wrap_new_IntInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_IntInMemoryNtuple", _wrap_delete_IntInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"IntInMemoryNtuple_nRows", _wrap_IntInMemoryNtuple_nRows, METH_VARARGS, NULL},
	{ (char *)"IntInMemoryNtuple_fill", _wrap_IntInMemoryNtuple_fill, METH_VARARGS, NULL},
	{ (char *)"IntInMemoryNtuple___call__", _wrap_IntInMemoryNtuple___call__, METH_VARARGS, NULL},
	{ (char *)"IntInMemoryNtuple_at", _wrap_IntInMemoryNtuple_at, METH_VARARGS, NULL},
	{ (char *)"IntInMemoryNtuple_clear", _wrap_IntInMemoryNtuple_clear, METH_VARARGS, NULL},
	{ (char *)"IntInMemoryNtuple_rowContents", _wrap_IntInMemoryNtuple_rowContents, METH_VARARGS, NULL},
	{ (char *)"IntInMemoryNtuple_columnContents", _wrap_IntInMemoryNtuple_columnContents, METH_VARARGS, NULL},
	{ (char *)"IntInMemoryNtuple_classId", _wrap_IntInMemoryNtuple_classId, METH_VARARGS, NULL},
	{ (char *)"IntInMemoryNtuple_write", _wrap_IntInMemoryNtuple_write, METH_VARARGS, NULL},
	{ (char *)"IntInMemoryNtuple_classname", _wrap_IntInMemoryNtuple_classname, METH_VARARGS, NULL},
	{ (char *)"IntInMemoryNtuple_version", _wrap_IntInMemoryNtuple_version, METH_VARARGS, NULL},
	{ (char *)"IntInMemoryNtuple_read", _wrap_IntInMemoryNtuple_read, METH_VARARGS, NULL},
	{ (char *)"IntInMemoryNtuple_swigregister", IntInMemoryNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_IntInMemoryNtuple", _wrap_new_ArchiveRecord_IntInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_IntInMemoryNtuple", _wrap_delete_ArchiveRecord_IntInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_IntInMemoryNtuple_swigregister", ArchiveRecord_IntInMemoryNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_IntInMemoryNtuple", _wrap_new_Ref_IntInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"Ref_IntInMemoryNtuple_restore", _wrap_Ref_IntInMemoryNtuple_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_IntInMemoryNtuple_retrieve", _wrap_Ref_IntInMemoryNtuple_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_IntInMemoryNtuple_getValue", _wrap_Ref_IntInMemoryNtuple_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_IntInMemoryNtuple", _wrap_delete_Ref_IntInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"Ref_IntInMemoryNtuple_swigregister", Ref_IntInMemoryNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongInMemoryNtuple", _wrap_new_LLongInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_LLongInMemoryNtuple", _wrap_delete_LLongInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"LLongInMemoryNtuple_nRows", _wrap_LLongInMemoryNtuple_nRows, METH_VARARGS, NULL},
	{ (char *)"LLongInMemoryNtuple_fill", _wrap_LLongInMemoryNtuple_fill, METH_VARARGS, NULL},
	{ (char *)"LLongInMemoryNtuple___call__", _wrap_LLongInMemoryNtuple___call__, METH_VARARGS, NULL},
	{ (char *)"LLongInMemoryNtuple_at", _wrap_LLongInMemoryNtuple_at, METH_VARARGS, NULL},
	{ (char *)"LLongInMemoryNtuple_clear", _wrap_LLongInMemoryNtuple_clear, METH_VARARGS, NULL},
	{ (char *)"LLongInMemoryNtuple_rowContents", _wrap_LLongInMemoryNtuple_rowContents, METH_VARARGS, NULL},
	{ (char *)"LLongInMemoryNtuple_columnContents", _wrap_LLongInMemoryNtuple_columnContents, METH_VARARGS, NULL},
	{ (char *)"LLongInMemoryNtuple_classId", _wrap_LLongInMemoryNtuple_classId, METH_VARARGS, NULL},
	{ (char *)"LLongInMemoryNtuple_write", _wrap_LLongInMemoryNtuple_write, METH_VARARGS, NULL},
	{ (char *)"LLongInMemoryNtuple_classname", _wrap_LLongInMemoryNtuple_classname, METH_VARARGS, NULL},
	{ (char *)"LLongInMemoryNtuple_version", _wrap_LLongInMemoryNtuple_version, METH_VARARGS, NULL},
	{ (char *)"LLongInMemoryNtuple_read", _wrap_LLongInMemoryNtuple_read, METH_VARARGS, NULL},
	{ (char *)"LLongInMemoryNtuple_swigregister", LLongInMemoryNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_LLongInMemoryNtuple", _wrap_new_ArchiveRecord_LLongInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_LLongInMemoryNtuple", _wrap_delete_ArchiveRecord_LLongInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_LLongInMemoryNtuple_swigregister", ArchiveRecord_LLongInMemoryNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_LLongInMemoryNtuple", _wrap_new_Ref_LLongInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongInMemoryNtuple_restore", _wrap_Ref_LLongInMemoryNtuple_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongInMemoryNtuple_retrieve", _wrap_Ref_LLongInMemoryNtuple_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongInMemoryNtuple_getValue", _wrap_Ref_LLongInMemoryNtuple_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_LLongInMemoryNtuple", _wrap_delete_Ref_LLongInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongInMemoryNtuple_swigregister", Ref_LLongInMemoryNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatInMemoryNtuple", _wrap_new_FloatInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_FloatInMemoryNtuple", _wrap_delete_FloatInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"FloatInMemoryNtuple_nRows", _wrap_FloatInMemoryNtuple_nRows, METH_VARARGS, NULL},
	{ (char *)"FloatInMemoryNtuple_fill", _wrap_FloatInMemoryNtuple_fill, METH_VARARGS, NULL},
	{ (char *)"FloatInMemoryNtuple___call__", _wrap_FloatInMemoryNtuple___call__, METH_VARARGS, NULL},
	{ (char *)"FloatInMemoryNtuple_at", _wrap_FloatInMemoryNtuple_at, METH_VARARGS, NULL},
	{ (char *)"FloatInMemoryNtuple_clear", _wrap_FloatInMemoryNtuple_clear, METH_VARARGS, NULL},
	{ (char *)"FloatInMemoryNtuple_rowContents", _wrap_FloatInMemoryNtuple_rowContents, METH_VARARGS, NULL},
	{ (char *)"FloatInMemoryNtuple_columnContents", _wrap_FloatInMemoryNtuple_columnContents, METH_VARARGS, NULL},
	{ (char *)"FloatInMemoryNtuple_classId", _wrap_FloatInMemoryNtuple_classId, METH_VARARGS, NULL},
	{ (char *)"FloatInMemoryNtuple_write", _wrap_FloatInMemoryNtuple_write, METH_VARARGS, NULL},
	{ (char *)"FloatInMemoryNtuple_classname", _wrap_FloatInMemoryNtuple_classname, METH_VARARGS, NULL},
	{ (char *)"FloatInMemoryNtuple_version", _wrap_FloatInMemoryNtuple_version, METH_VARARGS, NULL},
	{ (char *)"FloatInMemoryNtuple_read", _wrap_FloatInMemoryNtuple_read, METH_VARARGS, NULL},
	{ (char *)"FloatInMemoryNtuple_swigregister", FloatInMemoryNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_FloatInMemoryNtuple", _wrap_new_ArchiveRecord_FloatInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_FloatInMemoryNtuple", _wrap_delete_ArchiveRecord_FloatInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_FloatInMemoryNtuple_swigregister", ArchiveRecord_FloatInMemoryNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_FloatInMemoryNtuple", _wrap_new_Ref_FloatInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatInMemoryNtuple_restore", _wrap_Ref_FloatInMemoryNtuple_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatInMemoryNtuple_retrieve", _wrap_Ref_FloatInMemoryNtuple_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatInMemoryNtuple_getValue", _wrap_Ref_FloatInMemoryNtuple_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_FloatInMemoryNtuple", _wrap_delete_Ref_FloatInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatInMemoryNtuple_swigregister", Ref_FloatInMemoryNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleInMemoryNtuple", _wrap_new_DoubleInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleInMemoryNtuple", _wrap_delete_DoubleInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"DoubleInMemoryNtuple_nRows", _wrap_DoubleInMemoryNtuple_nRows, METH_VARARGS, NULL},
	{ (char *)"DoubleInMemoryNtuple_fill", _wrap_DoubleInMemoryNtuple_fill, METH_VARARGS, NULL},
	{ (char *)"DoubleInMemoryNtuple___call__", _wrap_DoubleInMemoryNtuple___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleInMemoryNtuple_at", _wrap_DoubleInMemoryNtuple_at, METH_VARARGS, NULL},
	{ (char *)"DoubleInMemoryNtuple_clear", _wrap_DoubleInMemoryNtuple_clear, METH_VARARGS, NULL},
	{ (char *)"DoubleInMemoryNtuple_rowContents", _wrap_DoubleInMemoryNtuple_rowContents, METH_VARARGS, NULL},
	{ (char *)"DoubleInMemoryNtuple_columnContents", _wrap_DoubleInMemoryNtuple_columnContents, METH_VARARGS, NULL},
	{ (char *)"DoubleInMemoryNtuple_classId", _wrap_DoubleInMemoryNtuple_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleInMemoryNtuple_write", _wrap_DoubleInMemoryNtuple_write, METH_VARARGS, NULL},
	{ (char *)"DoubleInMemoryNtuple_classname", _wrap_DoubleInMemoryNtuple_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleInMemoryNtuple_version", _wrap_DoubleInMemoryNtuple_version, METH_VARARGS, NULL},
	{ (char *)"DoubleInMemoryNtuple_read", _wrap_DoubleInMemoryNtuple_read, METH_VARARGS, NULL},
	{ (char *)"DoubleInMemoryNtuple_swigregister", DoubleInMemoryNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DoubleInMemoryNtuple", _wrap_new_ArchiveRecord_DoubleInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DoubleInMemoryNtuple", _wrap_delete_ArchiveRecord_DoubleInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DoubleInMemoryNtuple_swigregister", ArchiveRecord_DoubleInMemoryNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DoubleInMemoryNtuple", _wrap_new_Ref_DoubleInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleInMemoryNtuple_restore", _wrap_Ref_DoubleInMemoryNtuple_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleInMemoryNtuple_retrieve", _wrap_Ref_DoubleInMemoryNtuple_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleInMemoryNtuple_getValue", _wrap_Ref_DoubleInMemoryNtuple_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DoubleInMemoryNtuple", _wrap_delete_Ref_DoubleInMemoryNtuple, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleInMemoryNtuple_swigregister", Ref_DoubleInMemoryNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"QuantileTable1D_clone", _wrap_QuantileTable1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_QuantileTable1D", _wrap_delete_QuantileTable1D, METH_VARARGS, NULL},
	{ (char *)"QuantileTable1D_classId", _wrap_QuantileTable1D_classId, METH_VARARGS, NULL},
	{ (char *)"QuantileTable1D_write", _wrap_QuantileTable1D_write, METH_VARARGS, NULL},
	{ (char *)"QuantileTable1D_classname", _wrap_QuantileTable1D_classname, METH_VARARGS, NULL},
	{ (char *)"QuantileTable1D_version", _wrap_QuantileTable1D_version, METH_VARARGS, NULL},
	{ (char *)"QuantileTable1D_read", _wrap_QuantileTable1D_read, METH_VARARGS, NULL},
	{ (char *)"QuantileTable1D_swigregister", QuantileTable1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_BoundaryHandling", _wrap_new_BoundaryHandling, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling_methodName", _wrap_BoundaryHandling_methodName, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling_parameters", _wrap_BoundaryHandling_parameters, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling_nParameters", _wrap_BoundaryHandling_nParameters, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling_methodId", _wrap_BoundaryHandling_methodId, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling___eq__", _wrap_BoundaryHandling___eq__, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling___ne__", _wrap_BoundaryHandling___ne__, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling___lt__", _wrap_BoundaryHandling___lt__, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling___gt__", _wrap_BoundaryHandling___gt__, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling_isValidMethodName", _wrap_BoundaryHandling_isValidMethodName, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling_validMethodNames", _wrap_BoundaryHandling_validMethodNames, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling_isParameterFree", _wrap_BoundaryHandling_isParameterFree, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling_parameterFreeNames", _wrap_BoundaryHandling_parameterFreeNames, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling_expectedNParameters", _wrap_BoundaryHandling_expectedNParameters, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling_classId", _wrap_BoundaryHandling_classId, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling_write", _wrap_BoundaryHandling_write, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling_classname", _wrap_BoundaryHandling_classname, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling_version", _wrap_BoundaryHandling_version, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling_restore", _wrap_BoundaryHandling_restore, METH_VARARGS, NULL},
	{ (char *)"delete_BoundaryHandling", _wrap_delete_BoundaryHandling, METH_VARARGS, NULL},
	{ (char *)"BoundaryHandling_swigregister", BoundaryHandling_swigregister, METH_VARARGS, NULL},
	{ (char *)"lorpeMise1D", _wrap_lorpeMise1D, METH_VARARGS, NULL},
	{ (char *)"new_StatAccumulatorPair", _wrap_new_StatAccumulatorPair, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorPair_first", _wrap_StatAccumulatorPair_first, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorPair_second", _wrap_StatAccumulatorPair_second, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorPair_crossSumsq", _wrap_StatAccumulatorPair_crossSumsq, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorPair_count", _wrap_StatAccumulatorPair_count, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorPair_cov", _wrap_StatAccumulatorPair_cov, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorPair_corr", _wrap_StatAccumulatorPair_corr, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorPair_accumulate", _wrap_StatAccumulatorPair_accumulate, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorPair_reset", _wrap_StatAccumulatorPair_reset, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorPair___iadd__", _wrap_StatAccumulatorPair___iadd__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorPair___eq__", _wrap_StatAccumulatorPair___eq__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorPair___ne__", _wrap_StatAccumulatorPair___ne__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorPair_classId", _wrap_StatAccumulatorPair_classId, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorPair_write", _wrap_StatAccumulatorPair_write, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorPair_classname", _wrap_StatAccumulatorPair_classname, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorPair_version", _wrap_StatAccumulatorPair_version, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorPair_restore", _wrap_StatAccumulatorPair_restore, METH_VARARGS, NULL},
	{ (char *)"delete_StatAccumulatorPair", _wrap_delete_StatAccumulatorPair, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorPair_swigregister", StatAccumulatorPair_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_StorableMultivariateFunctor", _wrap_delete_StorableMultivariateFunctor, METH_VARARGS, NULL},
	{ (char *)"StorableMultivariateFunctor_description", _wrap_StorableMultivariateFunctor_description, METH_VARARGS, NULL},
	{ (char *)"StorableMultivariateFunctor_setDescription", _wrap_StorableMultivariateFunctor_setDescription, METH_VARARGS, NULL},
	{ (char *)"StorableMultivariateFunctor_validateDescription", _wrap_StorableMultivariateFunctor_validateDescription, METH_VARARGS, NULL},
	{ (char *)"StorableMultivariateFunctor___eq__", _wrap_StorableMultivariateFunctor___eq__, METH_VARARGS, NULL},
	{ (char *)"StorableMultivariateFunctor___ne__", _wrap_StorableMultivariateFunctor___ne__, METH_VARARGS, NULL},
	{ (char *)"StorableMultivariateFunctor_classId", _wrap_StorableMultivariateFunctor_classId, METH_VARARGS, NULL},
	{ (char *)"StorableMultivariateFunctor_write", _wrap_StorableMultivariateFunctor_write, METH_VARARGS, NULL},
	{ (char *)"StorableMultivariateFunctor_classname", _wrap_StorableMultivariateFunctor_classname, METH_VARARGS, NULL},
	{ (char *)"StorableMultivariateFunctor_version", _wrap_StorableMultivariateFunctor_version, METH_VARARGS, NULL},
	{ (char *)"StorableMultivariateFunctor_read", _wrap_StorableMultivariateFunctor_read, METH_VARARGS, NULL},
	{ (char *)"StorableMultivariateFunctor_swigregister", StorableMultivariateFunctor_swigregister, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_nCoords", _wrap_UniformAxis_nCoords, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_min", _wrap_UniformAxis_min, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_max", _wrap_UniformAxis_max, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_label", _wrap_UniformAxis_label, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_usesLogSpace", _wrap_UniformAxis_usesLogSpace, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_getInterval", _wrap_UniformAxis_getInterval, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_linearInterval", _wrap_UniformAxis_linearInterval, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_coords", _wrap_UniformAxis_coords, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_coordinate", _wrap_UniformAxis_coordinate, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_length", _wrap_UniformAxis_length, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_isUniform", _wrap_UniformAxis_isUniform, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_nIntervals", _wrap_UniformAxis_nIntervals, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_intervalWidth", _wrap_UniformAxis_intervalWidth, METH_VARARGS, NULL},
	{ (char *)"UniformAxis___eq__", _wrap_UniformAxis___eq__, METH_VARARGS, NULL},
	{ (char *)"UniformAxis___ne__", _wrap_UniformAxis___ne__, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_isClose", _wrap_UniformAxis_isClose, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_setLabel", _wrap_UniformAxis_setLabel, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_classId", _wrap_UniformAxis_classId, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_write", _wrap_UniformAxis_write, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_classname", _wrap_UniformAxis_classname, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_version", _wrap_UniformAxis_version, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_read", _wrap_UniformAxis_read, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_range", _wrap_UniformAxis_range, METH_VARARGS, NULL},
	{ (char *)"new_UniformAxis", _wrap_new_UniformAxis, METH_VARARGS, NULL},
	{ (char *)"delete_UniformAxis", _wrap_delete_UniformAxis, METH_VARARGS, NULL},
	{ (char *)"UniformAxis_swigregister", UniformAxis_swigregister, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_iterator", _wrap_UniformAxisVector_iterator, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector___nonzero__", _wrap_UniformAxisVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector___bool__", _wrap_UniformAxisVector___bool__, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector___len__", _wrap_UniformAxisVector___len__, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector___getslice__", _wrap_UniformAxisVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector___setslice__", _wrap_UniformAxisVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector___delslice__", _wrap_UniformAxisVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector___delitem__", _wrap_UniformAxisVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector___getitem__", _wrap_UniformAxisVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector___setitem__", _wrap_UniformAxisVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_pop", _wrap_UniformAxisVector_pop, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_append", _wrap_UniformAxisVector_append, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_empty", _wrap_UniformAxisVector_empty, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_size", _wrap_UniformAxisVector_size, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_swap", _wrap_UniformAxisVector_swap, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_begin", _wrap_UniformAxisVector_begin, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_end", _wrap_UniformAxisVector_end, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_rbegin", _wrap_UniformAxisVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_rend", _wrap_UniformAxisVector_rend, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_clear", _wrap_UniformAxisVector_clear, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_get_allocator", _wrap_UniformAxisVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_pop_back", _wrap_UniformAxisVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_erase", _wrap_UniformAxisVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_UniformAxisVector", _wrap_new_UniformAxisVector, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_push_back", _wrap_UniformAxisVector_push_back, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_front", _wrap_UniformAxisVector_front, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_back", _wrap_UniformAxisVector_back, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_assign", _wrap_UniformAxisVector_assign, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_resize", _wrap_UniformAxisVector_resize, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_insert", _wrap_UniformAxisVector_insert, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_reserve", _wrap_UniformAxisVector_reserve, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_capacity", _wrap_UniformAxisVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_UniformAxisVector", _wrap_delete_UniformAxisVector, METH_VARARGS, NULL},
	{ (char *)"UniformAxisVector_swigregister", UniformAxisVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"DualAxis_isUniform", _wrap_DualAxis_isUniform, METH_VARARGS, NULL},
	{ (char *)"DualAxis_nCoords", _wrap_DualAxis_nCoords, METH_VARARGS, NULL},
	{ (char *)"DualAxis_min", _wrap_DualAxis_min, METH_VARARGS, NULL},
	{ (char *)"DualAxis_max", _wrap_DualAxis_max, METH_VARARGS, NULL},
	{ (char *)"DualAxis_label", _wrap_DualAxis_label, METH_VARARGS, NULL},
	{ (char *)"DualAxis_usesLogSpace", _wrap_DualAxis_usesLogSpace, METH_VARARGS, NULL},
	{ (char *)"DualAxis_getInterval", _wrap_DualAxis_getInterval, METH_VARARGS, NULL},
	{ (char *)"DualAxis_linearInterval", _wrap_DualAxis_linearInterval, METH_VARARGS, NULL},
	{ (char *)"DualAxis_coordinate", _wrap_DualAxis_coordinate, METH_VARARGS, NULL},
	{ (char *)"DualAxis_length", _wrap_DualAxis_length, METH_VARARGS, NULL},
	{ (char *)"DualAxis_nIntervals", _wrap_DualAxis_nIntervals, METH_VARARGS, NULL},
	{ (char *)"DualAxis_intervalWidth", _wrap_DualAxis_intervalWidth, METH_VARARGS, NULL},
	{ (char *)"DualAxis_coords", _wrap_DualAxis_coords, METH_VARARGS, NULL},
	{ (char *)"DualAxis___eq__", _wrap_DualAxis___eq__, METH_VARARGS, NULL},
	{ (char *)"DualAxis___ne__", _wrap_DualAxis___ne__, METH_VARARGS, NULL},
	{ (char *)"DualAxis_getGridAxis", _wrap_DualAxis_getGridAxis, METH_VARARGS, NULL},
	{ (char *)"DualAxis_getUniformAxis", _wrap_DualAxis_getUniformAxis, METH_VARARGS, NULL},
	{ (char *)"DualAxis_setLabel", _wrap_DualAxis_setLabel, METH_VARARGS, NULL},
	{ (char *)"DualAxis_classId", _wrap_DualAxis_classId, METH_VARARGS, NULL},
	{ (char *)"DualAxis_write", _wrap_DualAxis_write, METH_VARARGS, NULL},
	{ (char *)"DualAxis_classname", _wrap_DualAxis_classname, METH_VARARGS, NULL},
	{ (char *)"DualAxis_version", _wrap_DualAxis_version, METH_VARARGS, NULL},
	{ (char *)"DualAxis_read", _wrap_DualAxis_read, METH_VARARGS, NULL},
	{ (char *)"DualAxis_range", _wrap_DualAxis_range, METH_VARARGS, NULL},
	{ (char *)"new_DualAxis", _wrap_new_DualAxis, METH_VARARGS, NULL},
	{ (char *)"delete_DualAxis", _wrap_delete_DualAxis, METH_VARARGS, NULL},
	{ (char *)"DualAxis_swigregister", DualAxis_swigregister, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_iterator", _wrap_DualAxisVector_iterator, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector___nonzero__", _wrap_DualAxisVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector___bool__", _wrap_DualAxisVector___bool__, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector___len__", _wrap_DualAxisVector___len__, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector___getslice__", _wrap_DualAxisVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector___setslice__", _wrap_DualAxisVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector___delslice__", _wrap_DualAxisVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector___delitem__", _wrap_DualAxisVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector___getitem__", _wrap_DualAxisVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector___setitem__", _wrap_DualAxisVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_pop", _wrap_DualAxisVector_pop, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_append", _wrap_DualAxisVector_append, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_empty", _wrap_DualAxisVector_empty, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_size", _wrap_DualAxisVector_size, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_swap", _wrap_DualAxisVector_swap, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_begin", _wrap_DualAxisVector_begin, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_end", _wrap_DualAxisVector_end, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_rbegin", _wrap_DualAxisVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_rend", _wrap_DualAxisVector_rend, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_clear", _wrap_DualAxisVector_clear, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_get_allocator", _wrap_DualAxisVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_pop_back", _wrap_DualAxisVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_erase", _wrap_DualAxisVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_DualAxisVector", _wrap_new_DualAxisVector, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_push_back", _wrap_DualAxisVector_push_back, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_front", _wrap_DualAxisVector_front, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_back", _wrap_DualAxisVector_back, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_assign", _wrap_DualAxisVector_assign, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_resize", _wrap_DualAxisVector_resize, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_insert", _wrap_DualAxisVector_insert, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_reserve", _wrap_DualAxisVector_reserve, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_capacity", _wrap_DualAxisVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_DualAxisVector", _wrap_delete_DualAxisVector, METH_VARARGS, NULL},
	{ (char *)"DualAxisVector_swigregister", DualAxisVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleLinInterpolatedTableND", _wrap_new_DoubleLinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND___call__", _wrap_DoubleLinInterpolatedTableND___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_dim", _wrap_DoubleLinInterpolatedTableND_dim, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_axes", _wrap_DoubleLinInterpolatedTableND_axes, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_axis", _wrap_DoubleLinInterpolatedTableND_axis, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_length", _wrap_DoubleLinInterpolatedTableND_length, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_leftInterpolationLinear", _wrap_DoubleLinInterpolatedTableND_leftInterpolationLinear, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_rightInterpolationLinear", _wrap_DoubleLinInterpolatedTableND_rightInterpolationLinear, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_interpolationType", _wrap_DoubleLinInterpolatedTableND_interpolationType, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_functionLabel", _wrap_DoubleLinInterpolatedTableND_functionLabel, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_table", _wrap_DoubleLinInterpolatedTableND_table, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_getCoords", _wrap_DoubleLinInterpolatedTableND_getCoords, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_isUniformlyBinned", _wrap_DoubleLinInterpolatedTableND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_isWithinLimits", _wrap_DoubleLinInterpolatedTableND_isWithinLimits, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_setFunctionLabel", _wrap_DoubleLinInterpolatedTableND_setFunctionLabel, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND___eq__", _wrap_DoubleLinInterpolatedTableND___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND___ne__", _wrap_DoubleLinInterpolatedTableND___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_classId", _wrap_DoubleLinInterpolatedTableND_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_write", _wrap_DoubleLinInterpolatedTableND_write, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_classname", _wrap_DoubleLinInterpolatedTableND_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_version", _wrap_DoubleLinInterpolatedTableND_version, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_read", _wrap_DoubleLinInterpolatedTableND_read, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleLinInterpolatedTableND", _wrap_delete_DoubleLinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"DoubleLinInterpolatedTableND_swigregister", DoubleLinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleNULinInterpolatedTableND", _wrap_new_DoubleNULinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND___call__", _wrap_DoubleNULinInterpolatedTableND___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_dim", _wrap_DoubleNULinInterpolatedTableND_dim, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_axes", _wrap_DoubleNULinInterpolatedTableND_axes, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_axis", _wrap_DoubleNULinInterpolatedTableND_axis, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_length", _wrap_DoubleNULinInterpolatedTableND_length, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_leftInterpolationLinear", _wrap_DoubleNULinInterpolatedTableND_leftInterpolationLinear, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_rightInterpolationLinear", _wrap_DoubleNULinInterpolatedTableND_rightInterpolationLinear, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_interpolationType", _wrap_DoubleNULinInterpolatedTableND_interpolationType, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_functionLabel", _wrap_DoubleNULinInterpolatedTableND_functionLabel, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_table", _wrap_DoubleNULinInterpolatedTableND_table, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_getCoords", _wrap_DoubleNULinInterpolatedTableND_getCoords, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_isUniformlyBinned", _wrap_DoubleNULinInterpolatedTableND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_isWithinLimits", _wrap_DoubleNULinInterpolatedTableND_isWithinLimits, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_setFunctionLabel", _wrap_DoubleNULinInterpolatedTableND_setFunctionLabel, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND___eq__", _wrap_DoubleNULinInterpolatedTableND___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND___ne__", _wrap_DoubleNULinInterpolatedTableND___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_classId", _wrap_DoubleNULinInterpolatedTableND_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_write", _wrap_DoubleNULinInterpolatedTableND_write, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_classname", _wrap_DoubleNULinInterpolatedTableND_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_version", _wrap_DoubleNULinInterpolatedTableND_version, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_read", _wrap_DoubleNULinInterpolatedTableND_read, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleNULinInterpolatedTableND", _wrap_delete_DoubleNULinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"DoubleNULinInterpolatedTableND_swigregister", DoubleNULinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleDALinInterpolatedTableND", _wrap_new_DoubleDALinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND___call__", _wrap_DoubleDALinInterpolatedTableND___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_dim", _wrap_DoubleDALinInterpolatedTableND_dim, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_axes", _wrap_DoubleDALinInterpolatedTableND_axes, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_axis", _wrap_DoubleDALinInterpolatedTableND_axis, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_length", _wrap_DoubleDALinInterpolatedTableND_length, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_leftInterpolationLinear", _wrap_DoubleDALinInterpolatedTableND_leftInterpolationLinear, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_rightInterpolationLinear", _wrap_DoubleDALinInterpolatedTableND_rightInterpolationLinear, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_interpolationType", _wrap_DoubleDALinInterpolatedTableND_interpolationType, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_functionLabel", _wrap_DoubleDALinInterpolatedTableND_functionLabel, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_table", _wrap_DoubleDALinInterpolatedTableND_table, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_getCoords", _wrap_DoubleDALinInterpolatedTableND_getCoords, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_isUniformlyBinned", _wrap_DoubleDALinInterpolatedTableND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_isWithinLimits", _wrap_DoubleDALinInterpolatedTableND_isWithinLimits, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_setFunctionLabel", _wrap_DoubleDALinInterpolatedTableND_setFunctionLabel, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND___eq__", _wrap_DoubleDALinInterpolatedTableND___eq__, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND___ne__", _wrap_DoubleDALinInterpolatedTableND___ne__, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_classId", _wrap_DoubleDALinInterpolatedTableND_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_write", _wrap_DoubleDALinInterpolatedTableND_write, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_classname", _wrap_DoubleDALinInterpolatedTableND_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_version", _wrap_DoubleDALinInterpolatedTableND_version, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_read", _wrap_DoubleDALinInterpolatedTableND_read, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleDALinInterpolatedTableND", _wrap_delete_DoubleDALinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"DoubleDALinInterpolatedTableND_swigregister", DoubleDALinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatLinInterpolatedTableND", _wrap_new_FloatLinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND___call__", _wrap_FloatLinInterpolatedTableND___call__, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_dim", _wrap_FloatLinInterpolatedTableND_dim, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_axes", _wrap_FloatLinInterpolatedTableND_axes, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_axis", _wrap_FloatLinInterpolatedTableND_axis, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_length", _wrap_FloatLinInterpolatedTableND_length, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_leftInterpolationLinear", _wrap_FloatLinInterpolatedTableND_leftInterpolationLinear, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_rightInterpolationLinear", _wrap_FloatLinInterpolatedTableND_rightInterpolationLinear, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_interpolationType", _wrap_FloatLinInterpolatedTableND_interpolationType, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_functionLabel", _wrap_FloatLinInterpolatedTableND_functionLabel, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_table", _wrap_FloatLinInterpolatedTableND_table, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_getCoords", _wrap_FloatLinInterpolatedTableND_getCoords, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_isUniformlyBinned", _wrap_FloatLinInterpolatedTableND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_isWithinLimits", _wrap_FloatLinInterpolatedTableND_isWithinLimits, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_setFunctionLabel", _wrap_FloatLinInterpolatedTableND_setFunctionLabel, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND___eq__", _wrap_FloatLinInterpolatedTableND___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND___ne__", _wrap_FloatLinInterpolatedTableND___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_classId", _wrap_FloatLinInterpolatedTableND_classId, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_write", _wrap_FloatLinInterpolatedTableND_write, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_classname", _wrap_FloatLinInterpolatedTableND_classname, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_version", _wrap_FloatLinInterpolatedTableND_version, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_read", _wrap_FloatLinInterpolatedTableND_read, METH_VARARGS, NULL},
	{ (char *)"delete_FloatLinInterpolatedTableND", _wrap_delete_FloatLinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"FloatLinInterpolatedTableND_swigregister", FloatLinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatNULinInterpolatedTableND", _wrap_new_FloatNULinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND___call__", _wrap_FloatNULinInterpolatedTableND___call__, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_dim", _wrap_FloatNULinInterpolatedTableND_dim, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_axes", _wrap_FloatNULinInterpolatedTableND_axes, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_axis", _wrap_FloatNULinInterpolatedTableND_axis, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_length", _wrap_FloatNULinInterpolatedTableND_length, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_leftInterpolationLinear", _wrap_FloatNULinInterpolatedTableND_leftInterpolationLinear, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_rightInterpolationLinear", _wrap_FloatNULinInterpolatedTableND_rightInterpolationLinear, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_interpolationType", _wrap_FloatNULinInterpolatedTableND_interpolationType, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_functionLabel", _wrap_FloatNULinInterpolatedTableND_functionLabel, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_table", _wrap_FloatNULinInterpolatedTableND_table, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_getCoords", _wrap_FloatNULinInterpolatedTableND_getCoords, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_isUniformlyBinned", _wrap_FloatNULinInterpolatedTableND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_isWithinLimits", _wrap_FloatNULinInterpolatedTableND_isWithinLimits, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_setFunctionLabel", _wrap_FloatNULinInterpolatedTableND_setFunctionLabel, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND___eq__", _wrap_FloatNULinInterpolatedTableND___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND___ne__", _wrap_FloatNULinInterpolatedTableND___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_classId", _wrap_FloatNULinInterpolatedTableND_classId, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_write", _wrap_FloatNULinInterpolatedTableND_write, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_classname", _wrap_FloatNULinInterpolatedTableND_classname, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_version", _wrap_FloatNULinInterpolatedTableND_version, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_read", _wrap_FloatNULinInterpolatedTableND_read, METH_VARARGS, NULL},
	{ (char *)"delete_FloatNULinInterpolatedTableND", _wrap_delete_FloatNULinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"FloatNULinInterpolatedTableND_swigregister", FloatNULinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatDALinInterpolatedTableND", _wrap_new_FloatDALinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND___call__", _wrap_FloatDALinInterpolatedTableND___call__, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_dim", _wrap_FloatDALinInterpolatedTableND_dim, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_axes", _wrap_FloatDALinInterpolatedTableND_axes, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_axis", _wrap_FloatDALinInterpolatedTableND_axis, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_length", _wrap_FloatDALinInterpolatedTableND_length, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_leftInterpolationLinear", _wrap_FloatDALinInterpolatedTableND_leftInterpolationLinear, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_rightInterpolationLinear", _wrap_FloatDALinInterpolatedTableND_rightInterpolationLinear, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_interpolationType", _wrap_FloatDALinInterpolatedTableND_interpolationType, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_functionLabel", _wrap_FloatDALinInterpolatedTableND_functionLabel, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_table", _wrap_FloatDALinInterpolatedTableND_table, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_getCoords", _wrap_FloatDALinInterpolatedTableND_getCoords, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_isUniformlyBinned", _wrap_FloatDALinInterpolatedTableND_isUniformlyBinned, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_isWithinLimits", _wrap_FloatDALinInterpolatedTableND_isWithinLimits, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_setFunctionLabel", _wrap_FloatDALinInterpolatedTableND_setFunctionLabel, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND___eq__", _wrap_FloatDALinInterpolatedTableND___eq__, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND___ne__", _wrap_FloatDALinInterpolatedTableND___ne__, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_classId", _wrap_FloatDALinInterpolatedTableND_classId, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_write", _wrap_FloatDALinInterpolatedTableND_write, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_classname", _wrap_FloatDALinInterpolatedTableND_classname, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_version", _wrap_FloatDALinInterpolatedTableND_version, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_read", _wrap_FloatDALinInterpolatedTableND_read, METH_VARARGS, NULL},
	{ (char *)"delete_FloatDALinInterpolatedTableND", _wrap_delete_FloatDALinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"FloatDALinInterpolatedTableND_swigregister", FloatDALinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DoubleLinInterpolatedTableND", _wrap_new_ArchiveRecord_DoubleLinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DoubleLinInterpolatedTableND", _wrap_delete_ArchiveRecord_DoubleLinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DoubleLinInterpolatedTableND_swigregister", ArchiveRecord_DoubleLinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DoubleLinInterpolatedTableND", _wrap_new_Ref_DoubleLinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleLinInterpolatedTableND_restore", _wrap_Ref_DoubleLinInterpolatedTableND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleLinInterpolatedTableND_retrieve", _wrap_Ref_DoubleLinInterpolatedTableND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleLinInterpolatedTableND_getValue", _wrap_Ref_DoubleLinInterpolatedTableND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DoubleLinInterpolatedTableND", _wrap_delete_Ref_DoubleLinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleLinInterpolatedTableND_swigregister", Ref_DoubleLinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DoubleNULinInterpolatedTableND", _wrap_new_ArchiveRecord_DoubleNULinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DoubleNULinInterpolatedTableND", _wrap_delete_ArchiveRecord_DoubleNULinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DoubleNULinInterpolatedTableND_swigregister", ArchiveRecord_DoubleNULinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DoubleNULinInterpolatedTableND", _wrap_new_Ref_DoubleNULinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleNULinInterpolatedTableND_restore", _wrap_Ref_DoubleNULinInterpolatedTableND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleNULinInterpolatedTableND_retrieve", _wrap_Ref_DoubleNULinInterpolatedTableND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleNULinInterpolatedTableND_getValue", _wrap_Ref_DoubleNULinInterpolatedTableND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DoubleNULinInterpolatedTableND", _wrap_delete_Ref_DoubleNULinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleNULinInterpolatedTableND_swigregister", Ref_DoubleNULinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DoubleDALinInterpolatedTableND", _wrap_new_ArchiveRecord_DoubleDALinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DoubleDALinInterpolatedTableND", _wrap_delete_ArchiveRecord_DoubleDALinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DoubleDALinInterpolatedTableND_swigregister", ArchiveRecord_DoubleDALinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DoubleDALinInterpolatedTableND", _wrap_new_Ref_DoubleDALinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleDALinInterpolatedTableND_restore", _wrap_Ref_DoubleDALinInterpolatedTableND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleDALinInterpolatedTableND_retrieve", _wrap_Ref_DoubleDALinInterpolatedTableND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleDALinInterpolatedTableND_getValue", _wrap_Ref_DoubleDALinInterpolatedTableND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DoubleDALinInterpolatedTableND", _wrap_delete_Ref_DoubleDALinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleDALinInterpolatedTableND_swigregister", Ref_DoubleDALinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_FloatLinInterpolatedTableND", _wrap_new_ArchiveRecord_FloatLinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_FloatLinInterpolatedTableND", _wrap_delete_ArchiveRecord_FloatLinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_FloatLinInterpolatedTableND_swigregister", ArchiveRecord_FloatLinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_FloatLinInterpolatedTableND", _wrap_new_Ref_FloatLinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatLinInterpolatedTableND_restore", _wrap_Ref_FloatLinInterpolatedTableND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatLinInterpolatedTableND_retrieve", _wrap_Ref_FloatLinInterpolatedTableND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatLinInterpolatedTableND_getValue", _wrap_Ref_FloatLinInterpolatedTableND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_FloatLinInterpolatedTableND", _wrap_delete_Ref_FloatLinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatLinInterpolatedTableND_swigregister", Ref_FloatLinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_FloatNULinInterpolatedTableND", _wrap_new_ArchiveRecord_FloatNULinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_FloatNULinInterpolatedTableND", _wrap_delete_ArchiveRecord_FloatNULinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_FloatNULinInterpolatedTableND_swigregister", ArchiveRecord_FloatNULinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_FloatNULinInterpolatedTableND", _wrap_new_Ref_FloatNULinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatNULinInterpolatedTableND_restore", _wrap_Ref_FloatNULinInterpolatedTableND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatNULinInterpolatedTableND_retrieve", _wrap_Ref_FloatNULinInterpolatedTableND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatNULinInterpolatedTableND_getValue", _wrap_Ref_FloatNULinInterpolatedTableND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_FloatNULinInterpolatedTableND", _wrap_delete_Ref_FloatNULinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatNULinInterpolatedTableND_swigregister", Ref_FloatNULinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_FloatDALinInterpolatedTableND", _wrap_new_ArchiveRecord_FloatDALinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_FloatDALinInterpolatedTableND", _wrap_delete_ArchiveRecord_FloatDALinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_FloatDALinInterpolatedTableND_swigregister", ArchiveRecord_FloatDALinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_FloatDALinInterpolatedTableND", _wrap_new_Ref_FloatDALinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatDALinInterpolatedTableND_restore", _wrap_Ref_FloatDALinInterpolatedTableND_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatDALinInterpolatedTableND_retrieve", _wrap_Ref_FloatDALinInterpolatedTableND_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatDALinInterpolatedTableND_getValue", _wrap_Ref_FloatDALinInterpolatedTableND_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_FloatDALinInterpolatedTableND", _wrap_delete_Ref_FloatDALinInterpolatedTableND, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatDALinInterpolatedTableND_swigregister", Ref_FloatDALinInterpolatedTableND_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatUAInterpolationFunctor", _wrap_new_FloatUAInterpolationFunctor, METH_VARARGS, NULL},
	{ (char *)"delete_FloatUAInterpolationFunctor", _wrap_delete_FloatUAInterpolationFunctor, METH_VARARGS, NULL},
	{ (char *)"FloatUAInterpolationFunctor_minDim", _wrap_FloatUAInterpolationFunctor_minDim, METH_VARARGS, NULL},
	{ (char *)"FloatUAInterpolationFunctor___call__", _wrap_FloatUAInterpolationFunctor___call__, METH_VARARGS, NULL},
	{ (char *)"FloatUAInterpolationFunctor_interpolator", _wrap_FloatUAInterpolationFunctor_interpolator, METH_VARARGS, NULL},
	{ (char *)"FloatUAInterpolationFunctor_table", _wrap_FloatUAInterpolationFunctor_table, METH_VARARGS, NULL},
	{ (char *)"FloatUAInterpolationFunctor_setConverter", _wrap_FloatUAInterpolationFunctor_setConverter, METH_VARARGS, NULL},
	{ (char *)"FloatUAInterpolationFunctor_classId", _wrap_FloatUAInterpolationFunctor_classId, METH_VARARGS, NULL},
	{ (char *)"FloatUAInterpolationFunctor_write", _wrap_FloatUAInterpolationFunctor_write, METH_VARARGS, NULL},
	{ (char *)"FloatUAInterpolationFunctor_classname", _wrap_FloatUAInterpolationFunctor_classname, METH_VARARGS, NULL},
	{ (char *)"FloatUAInterpolationFunctor_version", _wrap_FloatUAInterpolationFunctor_version, METH_VARARGS, NULL},
	{ (char *)"FloatUAInterpolationFunctor_read", _wrap_FloatUAInterpolationFunctor_read, METH_VARARGS, NULL},
	{ (char *)"FloatUAInterpolationFunctor_swigregister", FloatUAInterpolationFunctor_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatNUInterpolationFunctor", _wrap_new_FloatNUInterpolationFunctor, METH_VARARGS, NULL},
	{ (char *)"delete_FloatNUInterpolationFunctor", _wrap_delete_FloatNUInterpolationFunctor, METH_VARARGS, NULL},
	{ (char *)"FloatNUInterpolationFunctor_minDim", _wrap_FloatNUInterpolationFunctor_minDim, METH_VARARGS, NULL},
	{ (char *)"FloatNUInterpolationFunctor___call__", _wrap_FloatNUInterpolationFunctor___call__, METH_VARARGS, NULL},
	{ (char *)"FloatNUInterpolationFunctor_interpolator", _wrap_FloatNUInterpolationFunctor_interpolator, METH_VARARGS, NULL},
	{ (char *)"FloatNUInterpolationFunctor_table", _wrap_FloatNUInterpolationFunctor_table, METH_VARARGS, NULL},
	{ (char *)"FloatNUInterpolationFunctor_setConverter", _wrap_FloatNUInterpolationFunctor_setConverter, METH_VARARGS, NULL},
	{ (char *)"FloatNUInterpolationFunctor_classId", _wrap_FloatNUInterpolationFunctor_classId, METH_VARARGS, NULL},
	{ (char *)"FloatNUInterpolationFunctor_write", _wrap_FloatNUInterpolationFunctor_write, METH_VARARGS, NULL},
	{ (char *)"FloatNUInterpolationFunctor_classname", _wrap_FloatNUInterpolationFunctor_classname, METH_VARARGS, NULL},
	{ (char *)"FloatNUInterpolationFunctor_version", _wrap_FloatNUInterpolationFunctor_version, METH_VARARGS, NULL},
	{ (char *)"FloatNUInterpolationFunctor_read", _wrap_FloatNUInterpolationFunctor_read, METH_VARARGS, NULL},
	{ (char *)"FloatNUInterpolationFunctor_swigregister", FloatNUInterpolationFunctor_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatInterpolationFunctor", _wrap_new_FloatInterpolationFunctor, METH_VARARGS, NULL},
	{ (char *)"delete_FloatInterpolationFunctor", _wrap_delete_FloatInterpolationFunctor, METH_VARARGS, NULL},
	{ (char *)"FloatInterpolationFunctor_minDim", _wrap_FloatInterpolationFunctor_minDim, METH_VARARGS, NULL},
	{ (char *)"FloatInterpolationFunctor___call__", _wrap_FloatInterpolationFunctor___call__, METH_VARARGS, NULL},
	{ (char *)"FloatInterpolationFunctor_interpolator", _wrap_FloatInterpolationFunctor_interpolator, METH_VARARGS, NULL},
	{ (char *)"FloatInterpolationFunctor_table", _wrap_FloatInterpolationFunctor_table, METH_VARARGS, NULL},
	{ (char *)"FloatInterpolationFunctor_setConverter", _wrap_FloatInterpolationFunctor_setConverter, METH_VARARGS, NULL},
	{ (char *)"FloatInterpolationFunctor_classId", _wrap_FloatInterpolationFunctor_classId, METH_VARARGS, NULL},
	{ (char *)"FloatInterpolationFunctor_write", _wrap_FloatInterpolationFunctor_write, METH_VARARGS, NULL},
	{ (char *)"FloatInterpolationFunctor_classname", _wrap_FloatInterpolationFunctor_classname, METH_VARARGS, NULL},
	{ (char *)"FloatInterpolationFunctor_version", _wrap_FloatInterpolationFunctor_version, METH_VARARGS, NULL},
	{ (char *)"FloatInterpolationFunctor_read", _wrap_FloatInterpolationFunctor_read, METH_VARARGS, NULL},
	{ (char *)"FloatInterpolationFunctor_swigregister", FloatInterpolationFunctor_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleUAInterpolationFunctor", _wrap_new_DoubleUAInterpolationFunctor, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleUAInterpolationFunctor", _wrap_delete_DoubleUAInterpolationFunctor, METH_VARARGS, NULL},
	{ (char *)"DoubleUAInterpolationFunctor_minDim", _wrap_DoubleUAInterpolationFunctor_minDim, METH_VARARGS, NULL},
	{ (char *)"DoubleUAInterpolationFunctor___call__", _wrap_DoubleUAInterpolationFunctor___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleUAInterpolationFunctor_interpolator", _wrap_DoubleUAInterpolationFunctor_interpolator, METH_VARARGS, NULL},
	{ (char *)"DoubleUAInterpolationFunctor_table", _wrap_DoubleUAInterpolationFunctor_table, METH_VARARGS, NULL},
	{ (char *)"DoubleUAInterpolationFunctor_setConverter", _wrap_DoubleUAInterpolationFunctor_setConverter, METH_VARARGS, NULL},
	{ (char *)"DoubleUAInterpolationFunctor_classId", _wrap_DoubleUAInterpolationFunctor_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleUAInterpolationFunctor_write", _wrap_DoubleUAInterpolationFunctor_write, METH_VARARGS, NULL},
	{ (char *)"DoubleUAInterpolationFunctor_classname", _wrap_DoubleUAInterpolationFunctor_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleUAInterpolationFunctor_version", _wrap_DoubleUAInterpolationFunctor_version, METH_VARARGS, NULL},
	{ (char *)"DoubleUAInterpolationFunctor_read", _wrap_DoubleUAInterpolationFunctor_read, METH_VARARGS, NULL},
	{ (char *)"DoubleUAInterpolationFunctor_swigregister", DoubleUAInterpolationFunctor_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleNUInterpolationFunctor", _wrap_new_DoubleNUInterpolationFunctor, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleNUInterpolationFunctor", _wrap_delete_DoubleNUInterpolationFunctor, METH_VARARGS, NULL},
	{ (char *)"DoubleNUInterpolationFunctor_minDim", _wrap_DoubleNUInterpolationFunctor_minDim, METH_VARARGS, NULL},
	{ (char *)"DoubleNUInterpolationFunctor___call__", _wrap_DoubleNUInterpolationFunctor___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleNUInterpolationFunctor_interpolator", _wrap_DoubleNUInterpolationFunctor_interpolator, METH_VARARGS, NULL},
	{ (char *)"DoubleNUInterpolationFunctor_table", _wrap_DoubleNUInterpolationFunctor_table, METH_VARARGS, NULL},
	{ (char *)"DoubleNUInterpolationFunctor_setConverter", _wrap_DoubleNUInterpolationFunctor_setConverter, METH_VARARGS, NULL},
	{ (char *)"DoubleNUInterpolationFunctor_classId", _wrap_DoubleNUInterpolationFunctor_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleNUInterpolationFunctor_write", _wrap_DoubleNUInterpolationFunctor_write, METH_VARARGS, NULL},
	{ (char *)"DoubleNUInterpolationFunctor_classname", _wrap_DoubleNUInterpolationFunctor_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleNUInterpolationFunctor_version", _wrap_DoubleNUInterpolationFunctor_version, METH_VARARGS, NULL},
	{ (char *)"DoubleNUInterpolationFunctor_read", _wrap_DoubleNUInterpolationFunctor_read, METH_VARARGS, NULL},
	{ (char *)"DoubleNUInterpolationFunctor_swigregister", DoubleNUInterpolationFunctor_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleInterpolationFunctor", _wrap_new_DoubleInterpolationFunctor, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleInterpolationFunctor", _wrap_delete_DoubleInterpolationFunctor, METH_VARARGS, NULL},
	{ (char *)"DoubleInterpolationFunctor_minDim", _wrap_DoubleInterpolationFunctor_minDim, METH_VARARGS, NULL},
	{ (char *)"DoubleInterpolationFunctor___call__", _wrap_DoubleInterpolationFunctor___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleInterpolationFunctor_interpolator", _wrap_DoubleInterpolationFunctor_interpolator, METH_VARARGS, NULL},
	{ (char *)"DoubleInterpolationFunctor_table", _wrap_DoubleInterpolationFunctor_table, METH_VARARGS, NULL},
	{ (char *)"DoubleInterpolationFunctor_setConverter", _wrap_DoubleInterpolationFunctor_setConverter, METH_VARARGS, NULL},
	{ (char *)"DoubleInterpolationFunctor_classId", _wrap_DoubleInterpolationFunctor_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleInterpolationFunctor_write", _wrap_DoubleInterpolationFunctor_write, METH_VARARGS, NULL},
	{ (char *)"DoubleInterpolationFunctor_classname", _wrap_DoubleInterpolationFunctor_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleInterpolationFunctor_version", _wrap_DoubleInterpolationFunctor_version, METH_VARARGS, NULL},
	{ (char *)"DoubleInterpolationFunctor_read", _wrap_DoubleInterpolationFunctor_read, METH_VARARGS, NULL},
	{ (char *)"DoubleInterpolationFunctor_swigregister", DoubleInterpolationFunctor_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_GaussianMixtureEntry", _wrap_new_GaussianMixtureEntry, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntry_weight", _wrap_GaussianMixtureEntry_weight, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntry_mean", _wrap_GaussianMixtureEntry_mean, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntry_stdev", _wrap_GaussianMixtureEntry_stdev, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntry___eq__", _wrap_GaussianMixtureEntry___eq__, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntry___ne__", _wrap_GaussianMixtureEntry___ne__, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntry_classId", _wrap_GaussianMixtureEntry_classId, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntry_write", _wrap_GaussianMixtureEntry_write, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntry_classname", _wrap_GaussianMixtureEntry_classname, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntry_version", _wrap_GaussianMixtureEntry_version, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntry_restore", _wrap_GaussianMixtureEntry_restore, METH_VARARGS, NULL},
	{ (char *)"delete_GaussianMixtureEntry", _wrap_delete_GaussianMixtureEntry, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntry_swigregister", GaussianMixtureEntry_swigregister, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_iterator", _wrap_GaussianMixtureEntryVector_iterator, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector___nonzero__", _wrap_GaussianMixtureEntryVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector___bool__", _wrap_GaussianMixtureEntryVector___bool__, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector___len__", _wrap_GaussianMixtureEntryVector___len__, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector___getslice__", _wrap_GaussianMixtureEntryVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector___setslice__", _wrap_GaussianMixtureEntryVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector___delslice__", _wrap_GaussianMixtureEntryVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector___delitem__", _wrap_GaussianMixtureEntryVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector___getitem__", _wrap_GaussianMixtureEntryVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector___setitem__", _wrap_GaussianMixtureEntryVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_pop", _wrap_GaussianMixtureEntryVector_pop, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_append", _wrap_GaussianMixtureEntryVector_append, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_empty", _wrap_GaussianMixtureEntryVector_empty, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_size", _wrap_GaussianMixtureEntryVector_size, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_swap", _wrap_GaussianMixtureEntryVector_swap, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_begin", _wrap_GaussianMixtureEntryVector_begin, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_end", _wrap_GaussianMixtureEntryVector_end, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_rbegin", _wrap_GaussianMixtureEntryVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_rend", _wrap_GaussianMixtureEntryVector_rend, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_clear", _wrap_GaussianMixtureEntryVector_clear, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_get_allocator", _wrap_GaussianMixtureEntryVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_pop_back", _wrap_GaussianMixtureEntryVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_erase", _wrap_GaussianMixtureEntryVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_GaussianMixtureEntryVector", _wrap_new_GaussianMixtureEntryVector, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_push_back", _wrap_GaussianMixtureEntryVector_push_back, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_front", _wrap_GaussianMixtureEntryVector_front, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_back", _wrap_GaussianMixtureEntryVector_back, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_assign", _wrap_GaussianMixtureEntryVector_assign, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_resize", _wrap_GaussianMixtureEntryVector_resize, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_insert", _wrap_GaussianMixtureEntryVector_insert, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_reserve", _wrap_GaussianMixtureEntryVector_reserve, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_capacity", _wrap_GaussianMixtureEntryVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_GaussianMixtureEntryVector", _wrap_delete_GaussianMixtureEntryVector, METH_VARARGS, NULL},
	{ (char *)"GaussianMixtureEntryVector_swigregister", GaussianMixtureEntryVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DiscreteTabulated1D", _wrap_new_DiscreteTabulated1D, METH_VARARGS, NULL},
	{ (char *)"delete_DiscreteTabulated1D", _wrap_delete_DiscreteTabulated1D, METH_VARARGS, NULL},
	{ (char *)"DiscreteTabulated1D_clone", _wrap_DiscreteTabulated1D_clone, METH_VARARGS, NULL},
	{ (char *)"DiscreteTabulated1D_probabilities", _wrap_DiscreteTabulated1D_probabilities, METH_VARARGS, NULL},
	{ (char *)"DiscreteTabulated1D_classId", _wrap_DiscreteTabulated1D_classId, METH_VARARGS, NULL},
	{ (char *)"DiscreteTabulated1D_write", _wrap_DiscreteTabulated1D_write, METH_VARARGS, NULL},
	{ (char *)"DiscreteTabulated1D_classname", _wrap_DiscreteTabulated1D_classname, METH_VARARGS, NULL},
	{ (char *)"DiscreteTabulated1D_version", _wrap_DiscreteTabulated1D_version, METH_VARARGS, NULL},
	{ (char *)"DiscreteTabulated1D_read", _wrap_DiscreteTabulated1D_read, METH_VARARGS, NULL},
	{ (char *)"DiscreteTabulated1D_swigregister", DiscreteTabulated1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"pooledDiscreteTabulated1D", _wrap_pooledDiscreteTabulated1D, METH_VARARGS, NULL},
	{ (char *)"new_Poisson1D", _wrap_new_Poisson1D, METH_VARARGS, NULL},
	{ (char *)"Poisson1D_clone", _wrap_Poisson1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_Poisson1D", _wrap_delete_Poisson1D, METH_VARARGS, NULL},
	{ (char *)"Poisson1D_mean", _wrap_Poisson1D_mean, METH_VARARGS, NULL},
	{ (char *)"Poisson1D_probability", _wrap_Poisson1D_probability, METH_VARARGS, NULL},
	{ (char *)"Poisson1D_cdf", _wrap_Poisson1D_cdf, METH_VARARGS, NULL},
	{ (char *)"Poisson1D_exceedance", _wrap_Poisson1D_exceedance, METH_VARARGS, NULL},
	{ (char *)"Poisson1D_quantile", _wrap_Poisson1D_quantile, METH_VARARGS, NULL},
	{ (char *)"Poisson1D_classId", _wrap_Poisson1D_classId, METH_VARARGS, NULL},
	{ (char *)"Poisson1D_write", _wrap_Poisson1D_write, METH_VARARGS, NULL},
	{ (char *)"Poisson1D_classname", _wrap_Poisson1D_classname, METH_VARARGS, NULL},
	{ (char *)"Poisson1D_version", _wrap_Poisson1D_version, METH_VARARGS, NULL},
	{ (char *)"Poisson1D_read", _wrap_Poisson1D_read, METH_VARARGS, NULL},
	{ (char *)"Poisson1D_swigregister", Poisson1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_DiscreteTabulated1D", _wrap_new_ArchiveRecord_DiscreteTabulated1D, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_DiscreteTabulated1D", _wrap_delete_ArchiveRecord_DiscreteTabulated1D, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_DiscreteTabulated1D_swigregister", ArchiveRecord_DiscreteTabulated1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DiscreteTabulated1D", _wrap_new_Ref_DiscreteTabulated1D, METH_VARARGS, NULL},
	{ (char *)"Ref_DiscreteTabulated1D_restore", _wrap_Ref_DiscreteTabulated1D_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_DiscreteTabulated1D_retrieve", _wrap_Ref_DiscreteTabulated1D_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DiscreteTabulated1D_getValue", _wrap_Ref_DiscreteTabulated1D_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DiscreteTabulated1D", _wrap_delete_Ref_DiscreteTabulated1D, METH_VARARGS, NULL},
	{ (char *)"Ref_DiscreteTabulated1D_swigregister", Ref_DiscreteTabulated1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_Poisson1D", _wrap_new_ArchiveRecord_Poisson1D, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_Poisson1D", _wrap_delete_ArchiveRecord_Poisson1D, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_Poisson1D_swigregister", ArchiveRecord_Poisson1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_Poisson1D", _wrap_new_Ref_Poisson1D, METH_VARARGS, NULL},
	{ (char *)"Ref_Poisson1D_restore", _wrap_Ref_Poisson1D_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_Poisson1D_retrieve", _wrap_Ref_Poisson1D_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_Poisson1D_getValue", _wrap_Ref_Poisson1D_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_Poisson1D", _wrap_delete_Ref_Poisson1D, METH_VARARGS, NULL},
	{ (char *)"Ref_Poisson1D_swigregister", Ref_Poisson1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LogMapper1d", _wrap_new_LogMapper1d, METH_VARARGS, NULL},
	{ (char *)"LogMapper1d___call__", _wrap_LogMapper1d___call__, METH_VARARGS, NULL},
	{ (char *)"LogMapper1d_a", _wrap_LogMapper1d_a, METH_VARARGS, NULL},
	{ (char *)"LogMapper1d_b", _wrap_LogMapper1d_b, METH_VARARGS, NULL},
	{ (char *)"delete_LogMapper1d", _wrap_delete_LogMapper1d, METH_VARARGS, NULL},
	{ (char *)"LogMapper1d_swigregister", LogMapper1d_swigregister, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_iterator", _wrap_LogMapper1dVector_iterator, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector___nonzero__", _wrap_LogMapper1dVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector___bool__", _wrap_LogMapper1dVector___bool__, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector___len__", _wrap_LogMapper1dVector___len__, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector___getslice__", _wrap_LogMapper1dVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector___setslice__", _wrap_LogMapper1dVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector___delslice__", _wrap_LogMapper1dVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector___delitem__", _wrap_LogMapper1dVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector___getitem__", _wrap_LogMapper1dVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector___setitem__", _wrap_LogMapper1dVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_pop", _wrap_LogMapper1dVector_pop, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_append", _wrap_LogMapper1dVector_append, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_empty", _wrap_LogMapper1dVector_empty, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_size", _wrap_LogMapper1dVector_size, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_swap", _wrap_LogMapper1dVector_swap, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_begin", _wrap_LogMapper1dVector_begin, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_end", _wrap_LogMapper1dVector_end, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_rbegin", _wrap_LogMapper1dVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_rend", _wrap_LogMapper1dVector_rend, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_clear", _wrap_LogMapper1dVector_clear, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_get_allocator", _wrap_LogMapper1dVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_pop_back", _wrap_LogMapper1dVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_erase", _wrap_LogMapper1dVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_LogMapper1dVector", _wrap_new_LogMapper1dVector, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_push_back", _wrap_LogMapper1dVector_push_back, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_front", _wrap_LogMapper1dVector_front, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_back", _wrap_LogMapper1dVector_back, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_assign", _wrap_LogMapper1dVector_assign, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_resize", _wrap_LogMapper1dVector_resize, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_insert", _wrap_LogMapper1dVector_insert, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_reserve", _wrap_LogMapper1dVector_reserve, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_capacity", _wrap_LogMapper1dVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_LogMapper1dVector", _wrap_delete_LogMapper1dVector, METH_VARARGS, NULL},
	{ (char *)"LogMapper1dVector_swigregister", LogMapper1dVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_LinInterpolatedTable1D", _wrap_delete_LinInterpolatedTable1D, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1D___call__", _wrap_LinInterpolatedTable1D___call__, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1D___eq__", _wrap_LinInterpolatedTable1D___eq__, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1D___ne__", _wrap_LinInterpolatedTable1D___ne__, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1D_xmin", _wrap_LinInterpolatedTable1D_xmin, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1D_xmax", _wrap_LinInterpolatedTable1D_xmax, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1D_npoints", _wrap_LinInterpolatedTable1D_npoints, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1D_leftExtrapolationLinear", _wrap_LinInterpolatedTable1D_leftExtrapolationLinear, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1D_rightExtrapolationLinear", _wrap_LinInterpolatedTable1D_rightExtrapolationLinear, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1D_data", _wrap_LinInterpolatedTable1D_data, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1D_isMonotonous", _wrap_LinInterpolatedTable1D_isMonotonous, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1D_classId", _wrap_LinInterpolatedTable1D_classId, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1D_write", _wrap_LinInterpolatedTable1D_write, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1D_classname", _wrap_LinInterpolatedTable1D_classname, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1D_version", _wrap_LinInterpolatedTable1D_version, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1D_read", _wrap_LinInterpolatedTable1D_read, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1D_inverse", _wrap_LinInterpolatedTable1D_inverse, METH_VARARGS, NULL},
	{ (char *)"new_LinInterpolatedTable1D", _wrap_new_LinInterpolatedTable1D, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1D_swigregister", LinInterpolatedTable1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ArchiveRecord_LinInterpolatedTable1D", _wrap_new_ArchiveRecord_LinInterpolatedTable1D, METH_VARARGS, NULL},
	{ (char *)"delete_ArchiveRecord_LinInterpolatedTable1D", _wrap_delete_ArchiveRecord_LinInterpolatedTable1D, METH_VARARGS, NULL},
	{ (char *)"ArchiveRecord_LinInterpolatedTable1D_swigregister", ArchiveRecord_LinInterpolatedTable1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_LinInterpolatedTable1D", _wrap_new_Ref_LinInterpolatedTable1D, METH_VARARGS, NULL},
	{ (char *)"Ref_LinInterpolatedTable1D_restore", _wrap_Ref_LinInterpolatedTable1D_restore, METH_VARARGS, NULL},
	{ (char *)"Ref_LinInterpolatedTable1D_retrieve", _wrap_Ref_LinInterpolatedTable1D_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_LinInterpolatedTable1D_getValue", _wrap_Ref_LinInterpolatedTable1D_getValue, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_LinInterpolatedTable1D", _wrap_delete_Ref_LinInterpolatedTable1D, METH_VARARGS, NULL},
	{ (char *)"Ref_LinInterpolatedTable1D_swigregister", Ref_LinInterpolatedTable1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_iterator", _wrap_LinInterpolatedTable1DVector_iterator, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector___nonzero__", _wrap_LinInterpolatedTable1DVector___nonzero__, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector___bool__", _wrap_LinInterpolatedTable1DVector___bool__, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector___len__", _wrap_LinInterpolatedTable1DVector___len__, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector___getslice__", _wrap_LinInterpolatedTable1DVector___getslice__, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector___setslice__", _wrap_LinInterpolatedTable1DVector___setslice__, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector___delslice__", _wrap_LinInterpolatedTable1DVector___delslice__, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector___delitem__", _wrap_LinInterpolatedTable1DVector___delitem__, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector___getitem__", _wrap_LinInterpolatedTable1DVector___getitem__, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector___setitem__", _wrap_LinInterpolatedTable1DVector___setitem__, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_pop", _wrap_LinInterpolatedTable1DVector_pop, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_append", _wrap_LinInterpolatedTable1DVector_append, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_empty", _wrap_LinInterpolatedTable1DVector_empty, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_size", _wrap_LinInterpolatedTable1DVector_size, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_swap", _wrap_LinInterpolatedTable1DVector_swap, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_begin", _wrap_LinInterpolatedTable1DVector_begin, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_end", _wrap_LinInterpolatedTable1DVector_end, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_rbegin", _wrap_LinInterpolatedTable1DVector_rbegin, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_rend", _wrap_LinInterpolatedTable1DVector_rend, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_clear", _wrap_LinInterpolatedTable1DVector_clear, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_get_allocator", _wrap_LinInterpolatedTable1DVector_get_allocator, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_pop_back", _wrap_LinInterpolatedTable1DVector_pop_back, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_erase", _wrap_LinInterpolatedTable1DVector_erase, METH_VARARGS, NULL},
	{ (char *)"new_LinInterpolatedTable1DVector", _wrap_new_LinInterpolatedTable1DVector, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_push_back", _wrap_LinInterpolatedTable1DVector_push_back, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_front", _wrap_LinInterpolatedTable1DVector_front, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_back", _wrap_LinInterpolatedTable1DVector_back, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_assign", _wrap_LinInterpolatedTable1DVector_assign, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_resize", _wrap_LinInterpolatedTable1DVector_resize, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_insert", _wrap_LinInterpolatedTable1DVector_insert, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_reserve", _wrap_LinInterpolatedTable1DVector_reserve, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_capacity", _wrap_LinInterpolatedTable1DVector_capacity, METH_VARARGS, NULL},
	{ (char *)"delete_LinInterpolatedTable1DVector", _wrap_delete_LinInterpolatedTable1DVector, METH_VARARGS, NULL},
	{ (char *)"LinInterpolatedTable1DVector_swigregister", LinInterpolatedTable1DVector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DensityScan1D", _wrap_new_DensityScan1D, METH_VARARGS, NULL},
	{ (char *)"DensityScan1D___call__", _wrap_DensityScan1D___call__, METH_VARARGS, NULL},
	{ (char *)"DensityScan1D_averageDensity", _wrap_DensityScan1D_averageDensity, METH_VARARGS, NULL},
	{ (char *)"delete_DensityScan1D", _wrap_delete_DensityScan1D, METH_VARARGS, NULL},
	{ (char *)"DensityScan1D_swigregister", DensityScan1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DensityDiscretizationError1D", _wrap_new_DensityDiscretizationError1D, METH_VARARGS, NULL},
	{ (char *)"delete_DensityDiscretizationError1D", _wrap_delete_DensityDiscretizationError1D, METH_VARARGS, NULL},
	{ (char *)"DensityDiscretizationError1D___call__", _wrap_DensityDiscretizationError1D___call__, METH_VARARGS, NULL},
	{ (char *)"DensityDiscretizationError1D_swigregister", DensityDiscretizationError1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DensityScan1D_Linear", _wrap_new_DensityScan1D_Linear, METH_VARARGS, NULL},
	{ (char *)"DensityScan1D_Linear___call__", _wrap_DensityScan1D_Linear___call__, METH_VARARGS, NULL},
	{ (char *)"delete_DensityScan1D_Linear", _wrap_delete_DensityScan1D_Linear, METH_VARARGS, NULL},
	{ (char *)"DensityScan1D_Linear_swigregister", DensityScan1D_Linear_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DensityScan1D_Log", _wrap_new_DensityScan1D_Log, METH_VARARGS, NULL},
	{ (char *)"DensityScan1D_Log___call__", _wrap_DensityScan1D_Log___call__, METH_VARARGS, NULL},
	{ (char *)"delete_DensityScan1D_Log", _wrap_delete_DensityScan1D_Log, METH_VARARGS, NULL},
	{ (char *)"DensityScan1D_Log_swigregister", DensityScan1D_Log_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DensityScan1D_Circular", _wrap_new_DensityScan1D_Circular, METH_VARARGS, NULL},
	{ (char *)"DensityScan1D_Circular___call__", _wrap_DensityScan1D_Circular___call__, METH_VARARGS, NULL},
	{ (char *)"delete_DensityScan1D_Circular", _wrap_delete_DensityScan1D_Circular, METH_VARARGS, NULL},
	{ (char *)"DensityScan1D_Circular_swigregister", DensityScan1D_Circular_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DensityScan1D_Interpolated", _wrap_new_DensityScan1D_Interpolated, METH_VARARGS, NULL},
	{ (char *)"DensityScan1D_Interpolated___call__", _wrap_DensityScan1D_Interpolated___call__, METH_VARARGS, NULL},
	{ (char *)"delete_DensityScan1D_Interpolated", _wrap_delete_DensityScan1D_Interpolated, METH_VARARGS, NULL},
	{ (char *)"DensityScan1D_Interpolated_swigregister", DensityScan1D_Interpolated_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DensityScan1D_Funct", _wrap_new_DensityScan1D_Funct, METH_VARARGS, NULL},
	{ (char *)"DensityScan1D_Funct___call__", _wrap_DensityScan1D_Funct___call__, METH_VARARGS, NULL},
	{ (char *)"delete_DensityScan1D_Funct", _wrap_delete_DensityScan1D_Funct, METH_VARARGS, NULL},
	{ (char *)"DensityScan1D_Funct_swigregister", DensityScan1D_Funct_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DensityScan1D_Fcn", _wrap_new_DensityScan1D_Fcn, METH_VARARGS, NULL},
	{ (char *)"DensityScan1D_Fcn___call__", _wrap_DensityScan1D_Fcn___call__, METH_VARARGS, NULL},
	{ (char *)"delete_DensityScan1D_Fcn", _wrap_delete_DensityScan1D_Fcn, METH_VARARGS, NULL},
	{ (char *)"DensityScan1D_Fcn_swigregister", DensityScan1D_Fcn_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsInterpolatedDistribution1D", _wrap_delete_AbsInterpolatedDistribution1D, METH_VARARGS, NULL},
	{ (char *)"AbsInterpolatedDistribution1D_clone", _wrap_AbsInterpolatedDistribution1D_clone, METH_VARARGS, NULL},
	{ (char *)"AbsInterpolatedDistribution1D_add", _wrap_AbsInterpolatedDistribution1D_add, METH_VARARGS, NULL},
	{ (char *)"AbsInterpolatedDistribution1D_replace", _wrap_AbsInterpolatedDistribution1D_replace, METH_VARARGS, NULL},
	{ (char *)"AbsInterpolatedDistribution1D_setWeight", _wrap_AbsInterpolatedDistribution1D_setWeight, METH_VARARGS, NULL},
	{ (char *)"AbsInterpolatedDistribution1D_clear", _wrap_AbsInterpolatedDistribution1D_clear, METH_VARARGS, NULL},
	{ (char *)"AbsInterpolatedDistribution1D_size", _wrap_AbsInterpolatedDistribution1D_size, METH_VARARGS, NULL},
	{ (char *)"AbsInterpolatedDistribution1D_expectedSize", _wrap_AbsInterpolatedDistribution1D_expectedSize, METH_VARARGS, NULL},
	{ (char *)"AbsInterpolatedDistribution1D_normalizeAutomatically", _wrap_AbsInterpolatedDistribution1D_normalizeAutomatically, METH_VARARGS, NULL},
	{ (char *)"AbsInterpolatedDistribution1D_swigregister", AbsInterpolatedDistribution1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_VerticallyInterpolatedDistribution1D", _wrap_new_VerticallyInterpolatedDistribution1D, METH_VARARGS, NULL},
	{ (char *)"delete_VerticallyInterpolatedDistribution1D", _wrap_delete_VerticallyInterpolatedDistribution1D, METH_VARARGS, NULL},
	{ (char *)"VerticallyInterpolatedDistribution1D_clone", _wrap_VerticallyInterpolatedDistribution1D_clone, METH_VARARGS, NULL},
	{ (char *)"VerticallyInterpolatedDistribution1D_add", _wrap_VerticallyInterpolatedDistribution1D_add, METH_VARARGS, NULL},
	{ (char *)"VerticallyInterpolatedDistribution1D_replace", _wrap_VerticallyInterpolatedDistribution1D_replace, METH_VARARGS, NULL},
	{ (char *)"VerticallyInterpolatedDistribution1D_setWeight", _wrap_VerticallyInterpolatedDistribution1D_setWeight, METH_VARARGS, NULL},
	{ (char *)"VerticallyInterpolatedDistribution1D_clear", _wrap_VerticallyInterpolatedDistribution1D_clear, METH_VARARGS, NULL},
	{ (char *)"VerticallyInterpolatedDistribution1D_normalizeAutomatically", _wrap_VerticallyInterpolatedDistribution1D_normalizeAutomatically, METH_VARARGS, NULL},
	{ (char *)"VerticallyInterpolatedDistribution1D_size", _wrap_VerticallyInterpolatedDistribution1D_size, METH_VARARGS, NULL},
	{ (char *)"VerticallyInterpolatedDistribution1D_expectedSize", _wrap_VerticallyInterpolatedDistribution1D_expectedSize, METH_VARARGS, NULL},
	{ (char *)"VerticallyInterpolatedDistribution1D_density", _wrap_VerticallyInterpolatedDistribution1D_density, METH_VARARGS, NULL},
	{ (char *)"VerticallyInterpolatedDistribution1D_cdf", _wrap_VerticallyInterpolatedDistribution1D_cdf, METH_VARARGS, NULL},
	{ (char *)"VerticallyInterpolatedDistribution1D_exceedance", _wrap_VerticallyInterpolatedDistribution1D_exceedance, METH_VARARGS, NULL},
	{ (char *)"VerticallyInterpolatedDistribution1D_quantile", _wrap_VerticallyInterpolatedDistribution1D_quantile, METH_VARARGS, NULL},
	{ (char *)"VerticallyInterpolatedDistribution1D_classId", _wrap_VerticallyInterpolatedDistribution1D_classId, METH_VARARGS, NULL},
	{ (char *)"VerticallyInterpolatedDistribution1D_classname", _wrap_VerticallyInterpolatedDistribution1D_classname, METH_VARARGS, NULL},
	{ (char *)"VerticallyInterpolatedDistribution1D_version", _wrap_VerticallyInterpolatedDistribution1D_version, METH_VARARGS, NULL},
	{ (char *)"VerticallyInterpolatedDistribution1D_swigregister", VerticallyInterpolatedDistribution1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_UCharAbsBandwidthCV1D", _wrap_delete_UCharAbsBandwidthCV1D, METH_VARARGS, NULL},
	{ (char *)"UCharAbsBandwidthCV1D___call__", _wrap_UCharAbsBandwidthCV1D___call__, METH_VARARGS, NULL},
	{ (char *)"UCharAbsBandwidthCV1D_swigregister", UCharAbsBandwidthCV1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_IntAbsBandwidthCV1D", _wrap_delete_IntAbsBandwidthCV1D, METH_VARARGS, NULL},
	{ (char *)"IntAbsBandwidthCV1D___call__", _wrap_IntAbsBandwidthCV1D___call__, METH_VARARGS, NULL},
	{ (char *)"IntAbsBandwidthCV1D_swigregister", IntAbsBandwidthCV1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_LLongAbsBandwidthCV1D", _wrap_delete_LLongAbsBandwidthCV1D, METH_VARARGS, NULL},
	{ (char *)"LLongAbsBandwidthCV1D___call__", _wrap_LLongAbsBandwidthCV1D___call__, METH_VARARGS, NULL},
	{ (char *)"LLongAbsBandwidthCV1D_swigregister", LLongAbsBandwidthCV1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_FloatAbsBandwidthCV1D", _wrap_delete_FloatAbsBandwidthCV1D, METH_VARARGS, NULL},
	{ (char *)"FloatAbsBandwidthCV1D___call__", _wrap_FloatAbsBandwidthCV1D___call__, METH_VARARGS, NULL},
	{ (char *)"FloatAbsBandwidthCV1D_swigregister", FloatAbsBandwidthCV1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleAbsBandwidthCV1D", _wrap_delete_DoubleAbsBandwidthCV1D, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsBandwidthCV1D___call__", _wrap_DoubleAbsBandwidthCV1D___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsBandwidthCV1D_swigregister", DoubleAbsBandwidthCV1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_UCharAbsBandwidthCVND", _wrap_delete_UCharAbsBandwidthCVND, METH_VARARGS, NULL},
	{ (char *)"UCharAbsBandwidthCVND___call__", _wrap_UCharAbsBandwidthCVND___call__, METH_VARARGS, NULL},
	{ (char *)"UCharAbsBandwidthCVND_swigregister", UCharAbsBandwidthCVND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_IntAbsBandwidthCVND", _wrap_delete_IntAbsBandwidthCVND, METH_VARARGS, NULL},
	{ (char *)"IntAbsBandwidthCVND___call__", _wrap_IntAbsBandwidthCVND___call__, METH_VARARGS, NULL},
	{ (char *)"IntAbsBandwidthCVND_swigregister", IntAbsBandwidthCVND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_LLongAbsBandwidthCVND", _wrap_delete_LLongAbsBandwidthCVND, METH_VARARGS, NULL},
	{ (char *)"LLongAbsBandwidthCVND___call__", _wrap_LLongAbsBandwidthCVND___call__, METH_VARARGS, NULL},
	{ (char *)"LLongAbsBandwidthCVND_swigregister", LLongAbsBandwidthCVND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_FloatAbsBandwidthCVND", _wrap_delete_FloatAbsBandwidthCVND, METH_VARARGS, NULL},
	{ (char *)"FloatAbsBandwidthCVND___call__", _wrap_FloatAbsBandwidthCVND___call__, METH_VARARGS, NULL},
	{ (char *)"FloatAbsBandwidthCVND_swigregister", FloatAbsBandwidthCVND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleAbsBandwidthCVND", _wrap_delete_DoubleAbsBandwidthCVND, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsBandwidthCVND___call__", _wrap_DoubleAbsBandwidthCVND___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleAbsBandwidthCVND_swigregister", DoubleAbsBandwidthCVND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_ConstantBandwidthSmootherND_4", _wrap_delete_ConstantBandwidthSmootherND_4, METH_VARARGS, NULL},
	{ (char *)"ConstantBandwidthSmootherND_4_dim", _wrap_ConstantBandwidthSmootherND_4_dim, METH_VARARGS, NULL},
	{ (char *)"ConstantBandwidthSmootherND_4_shape", _wrap_ConstantBandwidthSmootherND_4_shape, METH_VARARGS, NULL},
	{ (char *)"ConstantBandwidthSmootherND_4_shapeData", _wrap_ConstantBandwidthSmootherND_4_shapeData, METH_VARARGS, NULL},
	{ (char *)"ConstantBandwidthSmootherND_4_maxDegree", _wrap_ConstantBandwidthSmootherND_4_maxDegree, METH_VARARGS, NULL},
	{ (char *)"ConstantBandwidthSmootherND_4_mirrorsData", _wrap_ConstantBandwidthSmootherND_4_mirrorsData, METH_VARARGS, NULL},
	{ (char *)"ConstantBandwidthSmootherND_4_taper", _wrap_ConstantBandwidthSmootherND_4_taper, METH_VARARGS, NULL},
	{ (char *)"new_ConstantBandwidthSmootherND_4", _wrap_new_ConstantBandwidthSmootherND_4, METH_VARARGS, NULL},
	{ (char *)"ConstantBandwidthSmootherND_4_smoothHistogram", _wrap_ConstantBandwidthSmootherND_4_smoothHistogram, METH_VARARGS, NULL},
	{ (char *)"ConstantBandwidthSmootherND_4_swigregister", ConstantBandwidthSmootherND_4_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_RightCensoredDistribution", _wrap_new_RightCensoredDistribution, METH_VARARGS, NULL},
	{ (char *)"RightCensoredDistribution_clone", _wrap_RightCensoredDistribution_clone, METH_VARARGS, NULL},
	{ (char *)"delete_RightCensoredDistribution", _wrap_delete_RightCensoredDistribution, METH_VARARGS, NULL},
	{ (char *)"RightCensoredDistribution_visible", _wrap_RightCensoredDistribution_visible, METH_VARARGS, NULL},
	{ (char *)"RightCensoredDistribution_visibleFraction", _wrap_RightCensoredDistribution_visibleFraction, METH_VARARGS, NULL},
	{ (char *)"RightCensoredDistribution_effectiveInfinity", _wrap_RightCensoredDistribution_effectiveInfinity, METH_VARARGS, NULL},
	{ (char *)"RightCensoredDistribution_density", _wrap_RightCensoredDistribution_density, METH_VARARGS, NULL},
	{ (char *)"RightCensoredDistribution_cdf", _wrap_RightCensoredDistribution_cdf, METH_VARARGS, NULL},
	{ (char *)"RightCensoredDistribution_exceedance", _wrap_RightCensoredDistribution_exceedance, METH_VARARGS, NULL},
	{ (char *)"RightCensoredDistribution_quantile", _wrap_RightCensoredDistribution_quantile, METH_VARARGS, NULL},
	{ (char *)"RightCensoredDistribution_classId", _wrap_RightCensoredDistribution_classId, METH_VARARGS, NULL},
	{ (char *)"RightCensoredDistribution_write", _wrap_RightCensoredDistribution_write, METH_VARARGS, NULL},
	{ (char *)"RightCensoredDistribution_classname", _wrap_RightCensoredDistribution_classname, METH_VARARGS, NULL},
	{ (char *)"RightCensoredDistribution_version", _wrap_RightCensoredDistribution_version, METH_VARARGS, NULL},
	{ (char *)"RightCensoredDistribution_read", _wrap_RightCensoredDistribution_read, METH_VARARGS, NULL},
	{ (char *)"RightCensoredDistribution_swigregister", RightCensoredDistribution_swigregister, METH_VARARGS, NULL},
	{ (char *)"amisePluginBwGauss", _wrap_amisePluginBwGauss, METH_VARARGS, NULL},
	{ (char *)"approxAmisePluginBwGauss", _wrap_approxAmisePluginBwGauss, METH_VARARGS, NULL},
	{ (char *)"amisePluginBwSymbeta", _wrap_amisePluginBwSymbeta, METH_VARARGS, NULL},
	{ (char *)"symbetaBandwidthRatio", _wrap_symbetaBandwidthRatio, METH_VARARGS, NULL},
	{ (char *)"approxSymbetaBandwidthRatio", _wrap_approxSymbetaBandwidthRatio, METH_VARARGS, NULL},
	{ (char *)"amisePluginDegreeGauss", _wrap_amisePluginDegreeGauss, METH_VARARGS, NULL},
	{ (char *)"amisePluginDegreeSymbeta", _wrap_amisePluginDegreeSymbeta, METH_VARARGS, NULL},
	{ (char *)"maxFilterDegreeSupported", _wrap_maxFilterDegreeSupported, METH_VARARGS, NULL},
	{ (char *)"integralOfSymmetricBetaSquared", _wrap_integralOfSymmetricBetaSquared, METH_VARARGS, NULL},
	{ (char *)"new_GaussianMixture1D", _wrap_new_GaussianMixture1D, METH_VARARGS, NULL},
	{ (char *)"delete_GaussianMixture1D", _wrap_delete_GaussianMixture1D, METH_VARARGS, NULL},
	{ (char *)"GaussianMixture1D_clone", _wrap_GaussianMixture1D_clone, METH_VARARGS, NULL},
	{ (char *)"GaussianMixture1D_nentries", _wrap_GaussianMixture1D_nentries, METH_VARARGS, NULL},
	{ (char *)"GaussianMixture1D_entry", _wrap_GaussianMixture1D_entry, METH_VARARGS, NULL},
	{ (char *)"GaussianMixture1D_entries", _wrap_GaussianMixture1D_entries, METH_VARARGS, NULL},
	{ (char *)"GaussianMixture1D_mean", _wrap_GaussianMixture1D_mean, METH_VARARGS, NULL},
	{ (char *)"GaussianMixture1D_stdev", _wrap_GaussianMixture1D_stdev, METH_VARARGS, NULL},
	{ (char *)"GaussianMixture1D_gaussianMISE", _wrap_GaussianMixture1D_gaussianMISE, METH_VARARGS, NULL},
	{ (char *)"GaussianMixture1D_miseOptimalBw", _wrap_GaussianMixture1D_miseOptimalBw, METH_VARARGS, NULL},
	{ (char *)"GaussianMixture1D_classId", _wrap_GaussianMixture1D_classId, METH_VARARGS, NULL},
	{ (char *)"GaussianMixture1D_write", _wrap_GaussianMixture1D_write, METH_VARARGS, NULL},
	{ (char *)"GaussianMixture1D_classname", _wrap_GaussianMixture1D_classname, METH_VARARGS, NULL},
	{ (char *)"GaussianMixture1D_version", _wrap_GaussianMixture1D_version, METH_VARARGS, NULL},
	{ (char *)"GaussianMixture1D_read", _wrap_GaussianMixture1D_read, METH_VARARGS, NULL},
	{ (char *)"GaussianMixture1D_swigregister", GaussianMixture1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DensityScanND_Linear", _wrap_new_DensityScanND_Linear, METH_VARARGS, NULL},
	{ (char *)"DensityScanND_Linear___call__", _wrap_DensityScanND_Linear___call__, METH_VARARGS, NULL},
	{ (char *)"delete_DensityScanND_Linear", _wrap_delete_DensityScanND_Linear, METH_VARARGS, NULL},
	{ (char *)"DensityScanND_Linear_swigregister", DensityScanND_Linear_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DensityScanND_Log", _wrap_new_DensityScanND_Log, METH_VARARGS, NULL},
	{ (char *)"DensityScanND_Log___call__", _wrap_DensityScanND_Log___call__, METH_VARARGS, NULL},
	{ (char *)"delete_DensityScanND_Log", _wrap_delete_DensityScanND_Log, METH_VARARGS, NULL},
	{ (char *)"DensityScanND_Log_swigregister", DensityScanND_Log_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DensityScanND_Circular", _wrap_new_DensityScanND_Circular, METH_VARARGS, NULL},
	{ (char *)"DensityScanND_Circular___call__", _wrap_DensityScanND_Circular___call__, METH_VARARGS, NULL},
	{ (char *)"delete_DensityScanND_Circular", _wrap_delete_DensityScanND_Circular, METH_VARARGS, NULL},
	{ (char *)"DensityScanND_Circular_swigregister", DensityScanND_Circular_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DensityScanND_Interpolated", _wrap_new_DensityScanND_Interpolated, METH_VARARGS, NULL},
	{ (char *)"DensityScanND_Interpolated___call__", _wrap_DensityScanND_Interpolated___call__, METH_VARARGS, NULL},
	{ (char *)"delete_DensityScanND_Interpolated", _wrap_delete_DensityScanND_Interpolated, METH_VARARGS, NULL},
	{ (char *)"DensityScanND_Interpolated_swigregister", DensityScanND_Interpolated_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsPolyFilterND", _wrap_delete_AbsPolyFilterND, METH_VARARGS, NULL},
	{ (char *)"AbsPolyFilterND_dim", _wrap_AbsPolyFilterND_dim, METH_VARARGS, NULL},
	{ (char *)"AbsPolyFilterND_dataShape", _wrap_AbsPolyFilterND_dataShape, METH_VARARGS, NULL},
	{ (char *)"AbsPolyFilterND_selfContribution", _wrap_AbsPolyFilterND_selfContribution, METH_VARARGS, NULL},
	{ (char *)"AbsPolyFilterND_linearSelfContribution", _wrap_AbsPolyFilterND_linearSelfContribution, METH_VARARGS, NULL},
	{ (char *)"AbsPolyFilterND_swigregister", AbsPolyFilterND_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleDoubleAbsVisitor", _wrap_delete_DoubleDoubleAbsVisitor, METH_VARARGS, NULL},
	{ (char *)"DoubleDoubleAbsVisitor_clear", _wrap_DoubleDoubleAbsVisitor_clear, METH_VARARGS, NULL},
	{ (char *)"DoubleDoubleAbsVisitor_process", _wrap_DoubleDoubleAbsVisitor_process, METH_VARARGS, NULL},
	{ (char *)"DoubleDoubleAbsVisitor_result", _wrap_DoubleDoubleAbsVisitor_result, METH_VARARGS, NULL},
	{ (char *)"DoubleDoubleAbsVisitor_swigregister", DoubleDoubleAbsVisitor_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_FloatFloatAbsVisitor", _wrap_delete_FloatFloatAbsVisitor, METH_VARARGS, NULL},
	{ (char *)"FloatFloatAbsVisitor_clear", _wrap_FloatFloatAbsVisitor_clear, METH_VARARGS, NULL},
	{ (char *)"FloatFloatAbsVisitor_process", _wrap_FloatFloatAbsVisitor_process, METH_VARARGS, NULL},
	{ (char *)"FloatFloatAbsVisitor_result", _wrap_FloatFloatAbsVisitor_result, METH_VARARGS, NULL},
	{ (char *)"FloatFloatAbsVisitor_swigregister", FloatFloatAbsVisitor_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_IntIntAbsVisitor", _wrap_delete_IntIntAbsVisitor, METH_VARARGS, NULL},
	{ (char *)"IntIntAbsVisitor_clear", _wrap_IntIntAbsVisitor_clear, METH_VARARGS, NULL},
	{ (char *)"IntIntAbsVisitor_process", _wrap_IntIntAbsVisitor_process, METH_VARARGS, NULL},
	{ (char *)"IntIntAbsVisitor_result", _wrap_IntIntAbsVisitor_result, METH_VARARGS, NULL},
	{ (char *)"IntIntAbsVisitor_swigregister", IntIntAbsVisitor_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_LLongLLongAbsVisitor", _wrap_delete_LLongLLongAbsVisitor, METH_VARARGS, NULL},
	{ (char *)"LLongLLongAbsVisitor_clear", _wrap_LLongLLongAbsVisitor_clear, METH_VARARGS, NULL},
	{ (char *)"LLongLLongAbsVisitor_process", _wrap_LLongLLongAbsVisitor_process, METH_VARARGS, NULL},
	{ (char *)"LLongLLongAbsVisitor_result", _wrap_LLongLLongAbsVisitor_result, METH_VARARGS, NULL},
	{ (char *)"LLongLLongAbsVisitor_swigregister", LLongLLongAbsVisitor_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_UCharUCharAbsVisitor", _wrap_delete_UCharUCharAbsVisitor, METH_VARARGS, NULL},
	{ (char *)"UCharUCharAbsVisitor_clear", _wrap_UCharUCharAbsVisitor_clear, METH_VARARGS, NULL},
	{ (char *)"UCharUCharAbsVisitor_process", _wrap_UCharUCharAbsVisitor_process, METH_VARARGS, NULL},
	{ (char *)"UCharUCharAbsVisitor_result", _wrap_UCharUCharAbsVisitor_result, METH_VARARGS, NULL},
	{ (char *)"UCharUCharAbsVisitor_swigregister", UCharUCharAbsVisitor_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_FloatDoubleAbsVisitor", _wrap_delete_FloatDoubleAbsVisitor, METH_VARARGS, NULL},
	{ (char *)"FloatDoubleAbsVisitor_clear", _wrap_FloatDoubleAbsVisitor_clear, METH_VARARGS, NULL},
	{ (char *)"FloatDoubleAbsVisitor_process", _wrap_FloatDoubleAbsVisitor_process, METH_VARARGS, NULL},
	{ (char *)"FloatDoubleAbsVisitor_result", _wrap_FloatDoubleAbsVisitor_result, METH_VARARGS, NULL},
	{ (char *)"FloatDoubleAbsVisitor_swigregister", FloatDoubleAbsVisitor_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_IntDoubleAbsVisitor", _wrap_delete_IntDoubleAbsVisitor, METH_VARARGS, NULL},
	{ (char *)"IntDoubleAbsVisitor_clear", _wrap_IntDoubleAbsVisitor_clear, METH_VARARGS, NULL},
	{ (char *)"IntDoubleAbsVisitor_process", _wrap_IntDoubleAbsVisitor_process, METH_VARARGS, NULL},
	{ (char *)"IntDoubleAbsVisitor_result", _wrap_IntDoubleAbsVisitor_result, METH_VARARGS, NULL},
	{ (char *)"IntDoubleAbsVisitor_swigregister", IntDoubleAbsVisitor_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_LLongDoubleAbsVisitor", _wrap_delete_LLongDoubleAbsVisitor, METH_VARARGS, NULL},
	{ (char *)"LLongDoubleAbsVisitor_clear", _wrap_LLongDoubleAbsVisitor_clear, METH_VARARGS, NULL},
	{ (char *)"LLongDoubleAbsVisitor_process", _wrap_LLongDoubleAbsVisitor_process, METH_VARARGS, NULL},
	{ (char *)"LLongDoubleAbsVisitor_result", _wrap_LLongDoubleAbsVisitor_result, METH_VARARGS, NULL},
	{ (char *)"LLongDoubleAbsVisitor_swigregister", LLongDoubleAbsVisitor_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_UCharDoubleAbsVisitor", _wrap_delete_UCharDoubleAbsVisitor, METH_VARARGS, NULL},
	{ (char *)"UCharDoubleAbsVisitor_clear", _wrap_UCharDoubleAbsVisitor_clear, METH_VARARGS, NULL},
	{ (char *)"UCharDoubleAbsVisitor_process", _wrap_UCharDoubleAbsVisitor_process, METH_VARARGS, NULL},
	{ (char *)"UCharDoubleAbsVisitor_result", _wrap_UCharDoubleAbsVisitor_result, METH_VARARGS, NULL},
	{ (char *)"UCharDoubleAbsVisitor_swigregister", UCharDoubleAbsVisitor_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharArrayMinProjector", _wrap_new_UCharArrayMinProjector, METH_VARARGS, NULL},
	{ (char *)"delete_UCharArrayMinProjector", _wrap_delete_UCharArrayMinProjector, METH_VARARGS, NULL},
	{ (char *)"UCharArrayMinProjector_clear", _wrap_UCharArrayMinProjector_clear, METH_VARARGS, NULL},
	{ (char *)"UCharArrayMinProjector_result", _wrap_UCharArrayMinProjector_result, METH_VARARGS, NULL},
	{ (char *)"UCharArrayMinProjector_process", _wrap_UCharArrayMinProjector_process, METH_VARARGS, NULL},
	{ (char *)"UCharArrayMinProjector_swigregister", UCharArrayMinProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntArrayMinProjector", _wrap_new_IntArrayMinProjector, METH_VARARGS, NULL},
	{ (char *)"delete_IntArrayMinProjector", _wrap_delete_IntArrayMinProjector, METH_VARARGS, NULL},
	{ (char *)"IntArrayMinProjector_clear", _wrap_IntArrayMinProjector_clear, METH_VARARGS, NULL},
	{ (char *)"IntArrayMinProjector_result", _wrap_IntArrayMinProjector_result, METH_VARARGS, NULL},
	{ (char *)"IntArrayMinProjector_process", _wrap_IntArrayMinProjector_process, METH_VARARGS, NULL},
	{ (char *)"IntArrayMinProjector_swigregister", IntArrayMinProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongArrayMinProjector", _wrap_new_LLongArrayMinProjector, METH_VARARGS, NULL},
	{ (char *)"delete_LLongArrayMinProjector", _wrap_delete_LLongArrayMinProjector, METH_VARARGS, NULL},
	{ (char *)"LLongArrayMinProjector_clear", _wrap_LLongArrayMinProjector_clear, METH_VARARGS, NULL},
	{ (char *)"LLongArrayMinProjector_result", _wrap_LLongArrayMinProjector_result, METH_VARARGS, NULL},
	{ (char *)"LLongArrayMinProjector_process", _wrap_LLongArrayMinProjector_process, METH_VARARGS, NULL},
	{ (char *)"LLongArrayMinProjector_swigregister", LLongArrayMinProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatArrayMinProjector", _wrap_new_FloatArrayMinProjector, METH_VARARGS, NULL},
	{ (char *)"delete_FloatArrayMinProjector", _wrap_delete_FloatArrayMinProjector, METH_VARARGS, NULL},
	{ (char *)"FloatArrayMinProjector_clear", _wrap_FloatArrayMinProjector_clear, METH_VARARGS, NULL},
	{ (char *)"FloatArrayMinProjector_result", _wrap_FloatArrayMinProjector_result, METH_VARARGS, NULL},
	{ (char *)"FloatArrayMinProjector_process", _wrap_FloatArrayMinProjector_process, METH_VARARGS, NULL},
	{ (char *)"FloatArrayMinProjector_swigregister", FloatArrayMinProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleArrayMinProjector", _wrap_new_DoubleArrayMinProjector, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleArrayMinProjector", _wrap_delete_DoubleArrayMinProjector, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayMinProjector_clear", _wrap_DoubleArrayMinProjector_clear, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayMinProjector_result", _wrap_DoubleArrayMinProjector_result, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayMinProjector_process", _wrap_DoubleArrayMinProjector_process, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayMinProjector_swigregister", DoubleArrayMinProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharArrayMaxProjector", _wrap_new_UCharArrayMaxProjector, METH_VARARGS, NULL},
	{ (char *)"delete_UCharArrayMaxProjector", _wrap_delete_UCharArrayMaxProjector, METH_VARARGS, NULL},
	{ (char *)"UCharArrayMaxProjector_clear", _wrap_UCharArrayMaxProjector_clear, METH_VARARGS, NULL},
	{ (char *)"UCharArrayMaxProjector_result", _wrap_UCharArrayMaxProjector_result, METH_VARARGS, NULL},
	{ (char *)"UCharArrayMaxProjector_process", _wrap_UCharArrayMaxProjector_process, METH_VARARGS, NULL},
	{ (char *)"UCharArrayMaxProjector_swigregister", UCharArrayMaxProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntArrayMaxProjector", _wrap_new_IntArrayMaxProjector, METH_VARARGS, NULL},
	{ (char *)"delete_IntArrayMaxProjector", _wrap_delete_IntArrayMaxProjector, METH_VARARGS, NULL},
	{ (char *)"IntArrayMaxProjector_clear", _wrap_IntArrayMaxProjector_clear, METH_VARARGS, NULL},
	{ (char *)"IntArrayMaxProjector_result", _wrap_IntArrayMaxProjector_result, METH_VARARGS, NULL},
	{ (char *)"IntArrayMaxProjector_process", _wrap_IntArrayMaxProjector_process, METH_VARARGS, NULL},
	{ (char *)"IntArrayMaxProjector_swigregister", IntArrayMaxProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongArrayMaxProjector", _wrap_new_LLongArrayMaxProjector, METH_VARARGS, NULL},
	{ (char *)"delete_LLongArrayMaxProjector", _wrap_delete_LLongArrayMaxProjector, METH_VARARGS, NULL},
	{ (char *)"LLongArrayMaxProjector_clear", _wrap_LLongArrayMaxProjector_clear, METH_VARARGS, NULL},
	{ (char *)"LLongArrayMaxProjector_result", _wrap_LLongArrayMaxProjector_result, METH_VARARGS, NULL},
	{ (char *)"LLongArrayMaxProjector_process", _wrap_LLongArrayMaxProjector_process, METH_VARARGS, NULL},
	{ (char *)"LLongArrayMaxProjector_swigregister", LLongArrayMaxProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatArrayMaxProjector", _wrap_new_FloatArrayMaxProjector, METH_VARARGS, NULL},
	{ (char *)"delete_FloatArrayMaxProjector", _wrap_delete_FloatArrayMaxProjector, METH_VARARGS, NULL},
	{ (char *)"FloatArrayMaxProjector_clear", _wrap_FloatArrayMaxProjector_clear, METH_VARARGS, NULL},
	{ (char *)"FloatArrayMaxProjector_result", _wrap_FloatArrayMaxProjector_result, METH_VARARGS, NULL},
	{ (char *)"FloatArrayMaxProjector_process", _wrap_FloatArrayMaxProjector_process, METH_VARARGS, NULL},
	{ (char *)"FloatArrayMaxProjector_swigregister", FloatArrayMaxProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleArrayMaxProjector", _wrap_new_DoubleArrayMaxProjector, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleArrayMaxProjector", _wrap_delete_DoubleArrayMaxProjector, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayMaxProjector_clear", _wrap_DoubleArrayMaxProjector_clear, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayMaxProjector_result", _wrap_DoubleArrayMaxProjector_result, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayMaxProjector_process", _wrap_DoubleArrayMaxProjector_process, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayMaxProjector_swigregister", DoubleArrayMaxProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharArrayMedianProjector", _wrap_new_UCharArrayMedianProjector, METH_VARARGS, NULL},
	{ (char *)"delete_UCharArrayMedianProjector", _wrap_delete_UCharArrayMedianProjector, METH_VARARGS, NULL},
	{ (char *)"UCharArrayMedianProjector_clear", _wrap_UCharArrayMedianProjector_clear, METH_VARARGS, NULL},
	{ (char *)"UCharArrayMedianProjector_process", _wrap_UCharArrayMedianProjector_process, METH_VARARGS, NULL},
	{ (char *)"UCharArrayMedianProjector_result", _wrap_UCharArrayMedianProjector_result, METH_VARARGS, NULL},
	{ (char *)"UCharArrayMedianProjector_swigregister", UCharArrayMedianProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntArrayMedianProjector", _wrap_new_IntArrayMedianProjector, METH_VARARGS, NULL},
	{ (char *)"delete_IntArrayMedianProjector", _wrap_delete_IntArrayMedianProjector, METH_VARARGS, NULL},
	{ (char *)"IntArrayMedianProjector_clear", _wrap_IntArrayMedianProjector_clear, METH_VARARGS, NULL},
	{ (char *)"IntArrayMedianProjector_process", _wrap_IntArrayMedianProjector_process, METH_VARARGS, NULL},
	{ (char *)"IntArrayMedianProjector_result", _wrap_IntArrayMedianProjector_result, METH_VARARGS, NULL},
	{ (char *)"IntArrayMedianProjector_swigregister", IntArrayMedianProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongArrayMedianProjector", _wrap_new_LLongArrayMedianProjector, METH_VARARGS, NULL},
	{ (char *)"delete_LLongArrayMedianProjector", _wrap_delete_LLongArrayMedianProjector, METH_VARARGS, NULL},
	{ (char *)"LLongArrayMedianProjector_clear", _wrap_LLongArrayMedianProjector_clear, METH_VARARGS, NULL},
	{ (char *)"LLongArrayMedianProjector_process", _wrap_LLongArrayMedianProjector_process, METH_VARARGS, NULL},
	{ (char *)"LLongArrayMedianProjector_result", _wrap_LLongArrayMedianProjector_result, METH_VARARGS, NULL},
	{ (char *)"LLongArrayMedianProjector_swigregister", LLongArrayMedianProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatArrayMedianProjector", _wrap_new_FloatArrayMedianProjector, METH_VARARGS, NULL},
	{ (char *)"delete_FloatArrayMedianProjector", _wrap_delete_FloatArrayMedianProjector, METH_VARARGS, NULL},
	{ (char *)"FloatArrayMedianProjector_clear", _wrap_FloatArrayMedianProjector_clear, METH_VARARGS, NULL},
	{ (char *)"FloatArrayMedianProjector_process", _wrap_FloatArrayMedianProjector_process, METH_VARARGS, NULL},
	{ (char *)"FloatArrayMedianProjector_result", _wrap_FloatArrayMedianProjector_result, METH_VARARGS, NULL},
	{ (char *)"FloatArrayMedianProjector_swigregister", FloatArrayMedianProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleArrayMedianProjector", _wrap_new_DoubleArrayMedianProjector, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleArrayMedianProjector", _wrap_delete_DoubleArrayMedianProjector, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayMedianProjector_clear", _wrap_DoubleArrayMedianProjector_clear, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayMedianProjector_process", _wrap_DoubleArrayMedianProjector_process, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayMedianProjector_result", _wrap_DoubleArrayMedianProjector_result, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayMedianProjector_swigregister", DoubleArrayMedianProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharArrayRangeProjector", _wrap_new_UCharArrayRangeProjector, METH_VARARGS, NULL},
	{ (char *)"delete_UCharArrayRangeProjector", _wrap_delete_UCharArrayRangeProjector, METH_VARARGS, NULL},
	{ (char *)"UCharArrayRangeProjector_result", _wrap_UCharArrayRangeProjector_result, METH_VARARGS, NULL},
	{ (char *)"UCharArrayRangeProjector_swigregister", UCharArrayRangeProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntArrayRangeProjector", _wrap_new_IntArrayRangeProjector, METH_VARARGS, NULL},
	{ (char *)"delete_IntArrayRangeProjector", _wrap_delete_IntArrayRangeProjector, METH_VARARGS, NULL},
	{ (char *)"IntArrayRangeProjector_result", _wrap_IntArrayRangeProjector_result, METH_VARARGS, NULL},
	{ (char *)"IntArrayRangeProjector_swigregister", IntArrayRangeProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongArrayRangeProjector", _wrap_new_LLongArrayRangeProjector, METH_VARARGS, NULL},
	{ (char *)"delete_LLongArrayRangeProjector", _wrap_delete_LLongArrayRangeProjector, METH_VARARGS, NULL},
	{ (char *)"LLongArrayRangeProjector_result", _wrap_LLongArrayRangeProjector_result, METH_VARARGS, NULL},
	{ (char *)"LLongArrayRangeProjector_swigregister", LLongArrayRangeProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatArrayRangeProjector", _wrap_new_FloatArrayRangeProjector, METH_VARARGS, NULL},
	{ (char *)"delete_FloatArrayRangeProjector", _wrap_delete_FloatArrayRangeProjector, METH_VARARGS, NULL},
	{ (char *)"FloatArrayRangeProjector_result", _wrap_FloatArrayRangeProjector_result, METH_VARARGS, NULL},
	{ (char *)"FloatArrayRangeProjector_swigregister", FloatArrayRangeProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleArrayRangeProjector", _wrap_new_DoubleArrayRangeProjector, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleArrayRangeProjector", _wrap_delete_DoubleArrayRangeProjector, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayRangeProjector_result", _wrap_DoubleArrayRangeProjector_result, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayRangeProjector_swigregister", DoubleArrayRangeProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleArraySumProjector", _wrap_new_DoubleArraySumProjector, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleArraySumProjector", _wrap_delete_DoubleArraySumProjector, METH_VARARGS, NULL},
	{ (char *)"DoubleArraySumProjector_clear", _wrap_DoubleArraySumProjector_clear, METH_VARARGS, NULL},
	{ (char *)"DoubleArraySumProjector_result", _wrap_DoubleArraySumProjector_result, METH_VARARGS, NULL},
	{ (char *)"DoubleArraySumProjector_process", _wrap_DoubleArraySumProjector_process, METH_VARARGS, NULL},
	{ (char *)"DoubleArraySumProjector_swigregister", DoubleArraySumProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatArraySumProjector", _wrap_new_FloatArraySumProjector, METH_VARARGS, NULL},
	{ (char *)"delete_FloatArraySumProjector", _wrap_delete_FloatArraySumProjector, METH_VARARGS, NULL},
	{ (char *)"FloatArraySumProjector_clear", _wrap_FloatArraySumProjector_clear, METH_VARARGS, NULL},
	{ (char *)"FloatArraySumProjector_result", _wrap_FloatArraySumProjector_result, METH_VARARGS, NULL},
	{ (char *)"FloatArraySumProjector_process", _wrap_FloatArraySumProjector_process, METH_VARARGS, NULL},
	{ (char *)"FloatArraySumProjector_swigregister", FloatArraySumProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntArraySumProjector", _wrap_new_IntArraySumProjector, METH_VARARGS, NULL},
	{ (char *)"delete_IntArraySumProjector", _wrap_delete_IntArraySumProjector, METH_VARARGS, NULL},
	{ (char *)"IntArraySumProjector_clear", _wrap_IntArraySumProjector_clear, METH_VARARGS, NULL},
	{ (char *)"IntArraySumProjector_result", _wrap_IntArraySumProjector_result, METH_VARARGS, NULL},
	{ (char *)"IntArraySumProjector_process", _wrap_IntArraySumProjector_process, METH_VARARGS, NULL},
	{ (char *)"IntArraySumProjector_swigregister", IntArraySumProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongArraySumProjector", _wrap_new_LLongArraySumProjector, METH_VARARGS, NULL},
	{ (char *)"delete_LLongArraySumProjector", _wrap_delete_LLongArraySumProjector, METH_VARARGS, NULL},
	{ (char *)"LLongArraySumProjector_clear", _wrap_LLongArraySumProjector_clear, METH_VARARGS, NULL},
	{ (char *)"LLongArraySumProjector_result", _wrap_LLongArraySumProjector_result, METH_VARARGS, NULL},
	{ (char *)"LLongArraySumProjector_process", _wrap_LLongArraySumProjector_process, METH_VARARGS, NULL},
	{ (char *)"LLongArraySumProjector_swigregister", LLongArraySumProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharArraySumProjector", _wrap_new_UCharArraySumProjector, METH_VARARGS, NULL},
	{ (char *)"delete_UCharArraySumProjector", _wrap_delete_UCharArraySumProjector, METH_VARARGS, NULL},
	{ (char *)"UCharArraySumProjector_clear", _wrap_UCharArraySumProjector_clear, METH_VARARGS, NULL},
	{ (char *)"UCharArraySumProjector_result", _wrap_UCharArraySumProjector_result, METH_VARARGS, NULL},
	{ (char *)"UCharArraySumProjector_process", _wrap_UCharArraySumProjector_process, METH_VARARGS, NULL},
	{ (char *)"UCharArraySumProjector_swigregister", UCharArraySumProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleArrayMeanProjector", _wrap_new_DoubleArrayMeanProjector, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleArrayMeanProjector", _wrap_delete_DoubleArrayMeanProjector, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayMeanProjector_result", _wrap_DoubleArrayMeanProjector_result, METH_VARARGS, NULL},
	{ (char *)"DoubleArrayMeanProjector_swigregister", DoubleArrayMeanProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_FloatArrayMeanProjector", _wrap_new_FloatArrayMeanProjector, METH_VARARGS, NULL},
	{ (char *)"delete_FloatArrayMeanProjector", _wrap_delete_FloatArrayMeanProjector, METH_VARARGS, NULL},
	{ (char *)"FloatArrayMeanProjector_result", _wrap_FloatArrayMeanProjector_result, METH_VARARGS, NULL},
	{ (char *)"FloatArrayMeanProjector_swigregister", FloatArrayMeanProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_IntArrayMeanProjector", _wrap_new_IntArrayMeanProjector, METH_VARARGS, NULL},
	{ (char *)"delete_IntArrayMeanProjector", _wrap_delete_IntArrayMeanProjector, METH_VARARGS, NULL},
	{ (char *)"IntArrayMeanProjector_result", _wrap_IntArrayMeanProjector_result, METH_VARARGS, NULL},
	{ (char *)"IntArrayMeanProjector_swigregister", IntArrayMeanProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LLongArrayMeanProjector", _wrap_new_LLongArrayMeanProjector, METH_VARARGS, NULL},
	{ (char *)"delete_LLongArrayMeanProjector", _wrap_delete_LLongArrayMeanProjector, METH_VARARGS, NULL},
	{ (char *)"LLongArrayMeanProjector_result", _wrap_LLongArrayMeanProjector_result, METH_VARARGS, NULL},
	{ (char *)"LLongArrayMeanProjector_swigregister", LLongArrayMeanProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_UCharArrayMeanProjector", _wrap_new_UCharArrayMeanProjector, METH_VARARGS, NULL},
	{ (char *)"delete_UCharArrayMeanProjector", _wrap_delete_UCharArrayMeanProjector, METH_VARARGS, NULL},
	{ (char *)"UCharArrayMeanProjector_result", _wrap_UCharArrayMeanProjector_result, METH_VARARGS, NULL},
	{ (char *)"UCharArrayMeanProjector_swigregister", UCharArrayMeanProjector_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_KDE1DHOSymbetaKernel", _wrap_new_KDE1DHOSymbetaKernel, METH_VARARGS, NULL},
	{ (char *)"KDE1DHOSymbetaKernel_clone", _wrap_KDE1DHOSymbetaKernel_clone, METH_VARARGS, NULL},
	{ (char *)"delete_KDE1DHOSymbetaKernel", _wrap_delete_KDE1DHOSymbetaKernel, METH_VARARGS, NULL},
	{ (char *)"KDE1DHOSymbetaKernel_power", _wrap_KDE1DHOSymbetaKernel_power, METH_VARARGS, NULL},
	{ (char *)"KDE1DHOSymbetaKernel_filterDegree", _wrap_KDE1DHOSymbetaKernel_filterDegree, METH_VARARGS, NULL},
	{ (char *)"KDE1DHOSymbetaKernel_weight", _wrap_KDE1DHOSymbetaKernel_weight, METH_VARARGS, NULL},
	{ (char *)"KDE1DHOSymbetaKernel_xmin", _wrap_KDE1DHOSymbetaKernel_xmin, METH_VARARGS, NULL},
	{ (char *)"KDE1DHOSymbetaKernel_xmax", _wrap_KDE1DHOSymbetaKernel_xmax, METH_VARARGS, NULL},
	{ (char *)"KDE1DHOSymbetaKernel___call__", _wrap_KDE1DHOSymbetaKernel___call__, METH_VARARGS, NULL},
	{ (char *)"KDE1DHOSymbetaKernel_swigregister", KDE1DHOSymbetaKernel_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_RatioOfNormals", _wrap_new_RatioOfNormals, METH_VARARGS, NULL},
	{ (char *)"delete_RatioOfNormals", _wrap_delete_RatioOfNormals, METH_VARARGS, NULL},
	{ (char *)"RatioOfNormals_clone", _wrap_RatioOfNormals_clone, METH_VARARGS, NULL},
	{ (char *)"RatioOfNormals_density", _wrap_RatioOfNormals_density, METH_VARARGS, NULL},
	{ (char *)"RatioOfNormals_cdf", _wrap_RatioOfNormals_cdf, METH_VARARGS, NULL},
	{ (char *)"RatioOfNormals_exceedance", _wrap_RatioOfNormals_exceedance, METH_VARARGS, NULL},
	{ (char *)"RatioOfNormals_quantile", _wrap_RatioOfNormals_quantile, METH_VARARGS, NULL},
	{ (char *)"RatioOfNormals_classId", _wrap_RatioOfNormals_classId, METH_VARARGS, NULL},
	{ (char *)"RatioOfNormals_write", _wrap_RatioOfNormals_write, METH_VARARGS, NULL},
	{ (char *)"RatioOfNormals_classname", _wrap_RatioOfNormals_classname, METH_VARARGS, NULL},
	{ (char *)"RatioOfNormals_version", _wrap_RatioOfNormals_version, METH_VARARGS, NULL},
	{ (char *)"RatioOfNormals_read", _wrap_RatioOfNormals_read, METH_VARARGS, NULL},
	{ (char *)"RatioOfNormals_swigregister", RatioOfNormals_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsMarginalSmootherBase", _wrap_delete_AbsMarginalSmootherBase, METH_VARARGS, NULL},
	{ (char *)"AbsMarginalSmootherBase_setAxisLabel", _wrap_AbsMarginalSmootherBase_setAxisLabel, METH_VARARGS, NULL},
	{ (char *)"AbsMarginalSmootherBase_nBins", _wrap_AbsMarginalSmootherBase_nBins, METH_VARARGS, NULL},
	{ (char *)"AbsMarginalSmootherBase_xMin", _wrap_AbsMarginalSmootherBase_xMin, METH_VARARGS, NULL},
	{ (char *)"AbsMarginalSmootherBase_xMax", _wrap_AbsMarginalSmootherBase_xMax, METH_VARARGS, NULL},
	{ (char *)"AbsMarginalSmootherBase_binWidth", _wrap_AbsMarginalSmootherBase_binWidth, METH_VARARGS, NULL},
	{ (char *)"AbsMarginalSmootherBase_getAxisLabel", _wrap_AbsMarginalSmootherBase_getAxisLabel, METH_VARARGS, NULL},
	{ (char *)"AbsMarginalSmootherBase_lastBandwidth", _wrap_AbsMarginalSmootherBase_lastBandwidth, METH_VARARGS, NULL},
	{ (char *)"AbsMarginalSmootherBase_setArchive", _wrap_AbsMarginalSmootherBase_setArchive, METH_VARARGS, NULL},
	{ (char *)"AbsMarginalSmootherBase_unsetArchive", _wrap_AbsMarginalSmootherBase_unsetArchive, METH_VARARGS, NULL},
	{ (char *)"AbsMarginalSmootherBase_smooth", _wrap_AbsMarginalSmootherBase_smooth, METH_VARARGS, NULL},
	{ (char *)"AbsMarginalSmootherBase_weightedSmooth", _wrap_AbsMarginalSmootherBase_weightedSmooth, METH_VARARGS, NULL},
	{ (char *)"AbsMarginalSmootherBase_smoothArch", _wrap_AbsMarginalSmootherBase_smoothArch, METH_VARARGS, NULL},
	{ (char *)"AbsMarginalSmootherBase_weightedSmoothArch", _wrap_AbsMarginalSmootherBase_weightedSmoothArch, METH_VARARGS, NULL},
	{ (char *)"AbsMarginalSmootherBase_swigregister", AbsMarginalSmootherBase_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_ConstantBandwidthSmoother1D", _wrap_new_ConstantBandwidthSmoother1D, METH_VARARGS, NULL},
	{ (char *)"delete_ConstantBandwidthSmoother1D", _wrap_delete_ConstantBandwidthSmoother1D, METH_VARARGS, NULL},
	{ (char *)"ConstantBandwidthSmoother1D_symbetaPower", _wrap_ConstantBandwidthSmoother1D_symbetaPower, METH_VARARGS, NULL},
	{ (char *)"ConstantBandwidthSmoother1D_kernelOrder", _wrap_ConstantBandwidthSmoother1D_kernelOrder, METH_VARARGS, NULL},
	{ (char *)"ConstantBandwidthSmoother1D_fixedBandwidth", _wrap_ConstantBandwidthSmoother1D_fixedBandwidth, METH_VARARGS, NULL},
	{ (char *)"ConstantBandwidthSmoother1D_bwFactor", _wrap_ConstantBandwidthSmoother1D_bwFactor, METH_VARARGS, NULL},
	{ (char *)"ConstantBandwidthSmoother1D_mirrorsData", _wrap_ConstantBandwidthSmoother1D_mirrorsData, METH_VARARGS, NULL},
	{ (char *)"ConstantBandwidthSmoother1D_dataLen", _wrap_ConstantBandwidthSmoother1D_dataLen, METH_VARARGS, NULL},
	{ (char *)"ConstantBandwidthSmoother1D_selfContribution", _wrap_ConstantBandwidthSmoother1D_selfContribution, METH_VARARGS, NULL},
	{ (char *)"ConstantBandwidthSmoother1D_swigregister", ConstantBandwidthSmoother1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_CompositeDistribution1D", _wrap_new_CompositeDistribution1D, METH_VARARGS, NULL},
	{ (char *)"delete_CompositeDistribution1D", _wrap_delete_CompositeDistribution1D, METH_VARARGS, NULL},
	{ (char *)"CompositeDistribution1D_density", _wrap_CompositeDistribution1D_density, METH_VARARGS, NULL},
	{ (char *)"CompositeDistribution1D_cdf", _wrap_CompositeDistribution1D_cdf, METH_VARARGS, NULL},
	{ (char *)"CompositeDistribution1D_exceedance", _wrap_CompositeDistribution1D_exceedance, METH_VARARGS, NULL},
	{ (char *)"CompositeDistribution1D_quantile", _wrap_CompositeDistribution1D_quantile, METH_VARARGS, NULL},
	{ (char *)"CompositeDistribution1D_clone", _wrap_CompositeDistribution1D_clone, METH_VARARGS, NULL},
	{ (char *)"CompositeDistribution1D_G", _wrap_CompositeDistribution1D_G, METH_VARARGS, NULL},
	{ (char *)"CompositeDistribution1D_H", _wrap_CompositeDistribution1D_H, METH_VARARGS, NULL},
	{ (char *)"CompositeDistribution1D_classId", _wrap_CompositeDistribution1D_classId, METH_VARARGS, NULL},
	{ (char *)"CompositeDistribution1D_write", _wrap_CompositeDistribution1D_write, METH_VARARGS, NULL},
	{ (char *)"CompositeDistribution1D_classname", _wrap_CompositeDistribution1D_classname, METH_VARARGS, NULL},
	{ (char *)"CompositeDistribution1D_version", _wrap_CompositeDistribution1D_version, METH_VARARGS, NULL},
	{ (char *)"CompositeDistribution1D_read", _wrap_CompositeDistribution1D_read, METH_VARARGS, NULL},
	{ (char *)"CompositeDistribution1D_swigregister", CompositeDistribution1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DoubleKDE1D", _wrap_new_DoubleKDE1D, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleKDE1D", _wrap_delete_DoubleKDE1D, METH_VARARGS, NULL},
	{ (char *)"DoubleKDE1D_kernel", _wrap_DoubleKDE1D_kernel, METH_VARARGS, NULL},
	{ (char *)"DoubleKDE1D_coords", _wrap_DoubleKDE1D_coords, METH_VARARGS, NULL},
	{ (char *)"DoubleKDE1D_nCoords", _wrap_DoubleKDE1D_nCoords, METH_VARARGS, NULL},
	{ (char *)"DoubleKDE1D_minCoordinate", _wrap_DoubleKDE1D_minCoordinate, METH_VARARGS, NULL},
	{ (char *)"DoubleKDE1D_maxCoordinate", _wrap_DoubleKDE1D_maxCoordinate, METH_VARARGS, NULL},
	{ (char *)"DoubleKDE1D_density", _wrap_DoubleKDE1D_density, METH_VARARGS, NULL},
	{ (char *)"DoubleKDE1D_densityFunctor", _wrap_DoubleKDE1D_densityFunctor, METH_VARARGS, NULL},
	{ (char *)"DoubleKDE1D_rlcvFunctor", _wrap_DoubleKDE1D_rlcvFunctor, METH_VARARGS, NULL},
	{ (char *)"DoubleKDE1D_lscvFunctor", _wrap_DoubleKDE1D_lscvFunctor, METH_VARARGS, NULL},
	{ (char *)"DoubleKDE1D_integratedSquaredError", _wrap_DoubleKDE1D_integratedSquaredError, METH_VARARGS, NULL},
	{ (char *)"DoubleKDE1D_rlcv", _wrap_DoubleKDE1D_rlcv, METH_VARARGS, NULL},
	{ (char *)"DoubleKDE1D_lscv", _wrap_DoubleKDE1D_lscv, METH_VARARGS, NULL},
	{ (char *)"DoubleKDE1D_swigregister", DoubleKDE1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_WeightedStatAccumulatorPair", _wrap_new_WeightedStatAccumulatorPair, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair_first", _wrap_WeightedStatAccumulatorPair_first, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair_second", _wrap_WeightedStatAccumulatorPair_second, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair_crossSumsq", _wrap_WeightedStatAccumulatorPair_crossSumsq, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair_count", _wrap_WeightedStatAccumulatorPair_count, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair_ncalls", _wrap_WeightedStatAccumulatorPair_ncalls, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair_nfills", _wrap_WeightedStatAccumulatorPair_nfills, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair_cov", _wrap_WeightedStatAccumulatorPair_cov, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair_corr", _wrap_WeightedStatAccumulatorPair_corr, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair_accumulate", _wrap_WeightedStatAccumulatorPair_accumulate, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair_reset", _wrap_WeightedStatAccumulatorPair_reset, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair___iadd__", _wrap_WeightedStatAccumulatorPair___iadd__, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair_scaleWeights", _wrap_WeightedStatAccumulatorPair_scaleWeights, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair___eq__", _wrap_WeightedStatAccumulatorPair___eq__, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair___ne__", _wrap_WeightedStatAccumulatorPair___ne__, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair_classId", _wrap_WeightedStatAccumulatorPair_classId, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair_write", _wrap_WeightedStatAccumulatorPair_write, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair_classname", _wrap_WeightedStatAccumulatorPair_classname, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair_version", _wrap_WeightedStatAccumulatorPair_version, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair_restore", _wrap_WeightedStatAccumulatorPair_restore, METH_VARARGS, NULL},
	{ (char *)"delete_WeightedStatAccumulatorPair", _wrap_delete_WeightedStatAccumulatorPair, METH_VARARGS, NULL},
	{ (char *)"WeightedStatAccumulatorPair_swigregister", WeightedStatAccumulatorPair_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_LeftCensoredDistribution", _wrap_new_LeftCensoredDistribution, METH_VARARGS, NULL},
	{ (char *)"LeftCensoredDistribution_clone", _wrap_LeftCensoredDistribution_clone, METH_VARARGS, NULL},
	{ (char *)"delete_LeftCensoredDistribution", _wrap_delete_LeftCensoredDistribution, METH_VARARGS, NULL},
	{ (char *)"LeftCensoredDistribution_visible", _wrap_LeftCensoredDistribution_visible, METH_VARARGS, NULL},
	{ (char *)"LeftCensoredDistribution_visibleFraction", _wrap_LeftCensoredDistribution_visibleFraction, METH_VARARGS, NULL},
	{ (char *)"LeftCensoredDistribution_effectiveInfinity", _wrap_LeftCensoredDistribution_effectiveInfinity, METH_VARARGS, NULL},
	{ (char *)"LeftCensoredDistribution_density", _wrap_LeftCensoredDistribution_density, METH_VARARGS, NULL},
	{ (char *)"LeftCensoredDistribution_cdf", _wrap_LeftCensoredDistribution_cdf, METH_VARARGS, NULL},
	{ (char *)"LeftCensoredDistribution_exceedance", _wrap_LeftCensoredDistribution_exceedance, METH_VARARGS, NULL},
	{ (char *)"LeftCensoredDistribution_quantile", _wrap_LeftCensoredDistribution_quantile, METH_VARARGS, NULL},
	{ (char *)"LeftCensoredDistribution_classId", _wrap_LeftCensoredDistribution_classId, METH_VARARGS, NULL},
	{ (char *)"LeftCensoredDistribution_write", _wrap_LeftCensoredDistribution_write, METH_VARARGS, NULL},
	{ (char *)"LeftCensoredDistribution_classname", _wrap_LeftCensoredDistribution_classname, METH_VARARGS, NULL},
	{ (char *)"LeftCensoredDistribution_version", _wrap_LeftCensoredDistribution_version, METH_VARARGS, NULL},
	{ (char *)"LeftCensoredDistribution_read", _wrap_LeftCensoredDistribution_read, METH_VARARGS, NULL},
	{ (char *)"LeftCensoredDistribution_swigregister", LeftCensoredDistribution_swigregister, METH_VARARGS, NULL},
	{ (char *)"multinomialCovariance1D", _wrap_multinomialCovariance1D, METH_VARARGS, NULL},
	{ (char *)"new_DistributionMix1D", _wrap_new_DistributionMix1D, METH_VARARGS, NULL},
	{ (char *)"DistributionMix1D_clone", _wrap_DistributionMix1D_clone, METH_VARARGS, NULL},
	{ (char *)"delete_DistributionMix1D", _wrap_delete_DistributionMix1D, METH_VARARGS, NULL},
	{ (char *)"DistributionMix1D_add", _wrap_DistributionMix1D_add, METH_VARARGS, NULL},
	{ (char *)"DistributionMix1D_setWeights", _wrap_DistributionMix1D_setWeights, METH_VARARGS, NULL},
	{ (char *)"DistributionMix1D_nComponents", _wrap_DistributionMix1D_nComponents, METH_VARARGS, NULL},
	{ (char *)"DistributionMix1D_getComponent", _wrap_DistributionMix1D_getComponent, METH_VARARGS, NULL},
	{ (char *)"DistributionMix1D_getWeight", _wrap_DistributionMix1D_getWeight, METH_VARARGS, NULL},
	{ (char *)"DistributionMix1D_density", _wrap_DistributionMix1D_density, METH_VARARGS, NULL},
	{ (char *)"DistributionMix1D_cdf", _wrap_DistributionMix1D_cdf, METH_VARARGS, NULL},
	{ (char *)"DistributionMix1D_exceedance", _wrap_DistributionMix1D_exceedance, METH_VARARGS, NULL},
	{ (char *)"DistributionMix1D_quantile", _wrap_DistributionMix1D_quantile, METH_VARARGS, NULL},
	{ (char *)"DistributionMix1D_classId", _wrap_DistributionMix1D_classId, METH_VARARGS, NULL},
	{ (char *)"DistributionMix1D_write", _wrap_DistributionMix1D_write, METH_VARARGS, NULL},
	{ (char *)"DistributionMix1D_classname", _wrap_DistributionMix1D_classname, METH_VARARGS, NULL},
	{ (char *)"DistributionMix1D_version", _wrap_DistributionMix1D_version, METH_VARARGS, NULL},
	{ (char *)"DistributionMix1D_read", _wrap_DistributionMix1D_read, METH_VARARGS, NULL},
	{ (char *)"DistributionMix1D_swigregister", DistributionMix1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleHistoNDFunctor", _wrap_delete_DoubleHistoNDFunctor, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoNDFunctor_minDim", _wrap_DoubleHistoNDFunctor_minDim, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoNDFunctor___call__", _wrap_DoubleHistoNDFunctor___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoNDFunctor_interpolationDegree", _wrap_DoubleHistoNDFunctor_interpolationDegree, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoNDFunctor_setInterpolationDegree", _wrap_DoubleHistoNDFunctor_setInterpolationDegree, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoNDFunctor_interpolator", _wrap_DoubleHistoNDFunctor_interpolator, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoNDFunctor_table", _wrap_DoubleHistoNDFunctor_table, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoNDFunctor_setConverter", _wrap_DoubleHistoNDFunctor_setConverter, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoNDFunctor_classId", _wrap_DoubleHistoNDFunctor_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoNDFunctor_write", _wrap_DoubleHistoNDFunctor_write, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoNDFunctor_classname", _wrap_DoubleHistoNDFunctor_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoNDFunctor_version", _wrap_DoubleHistoNDFunctor_version, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoNDFunctor_read", _wrap_DoubleHistoNDFunctor_read, METH_VARARGS, NULL},
	{ (char *)"DoubleHistoNDFunctor_swigregister", DoubleHistoNDFunctor_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleUAHistoNDFunctor", _wrap_delete_DoubleUAHistoNDFunctor, METH_VARARGS, NULL},
	{ (char *)"DoubleUAHistoNDFunctor_minDim", _wrap_DoubleUAHistoNDFunctor_minDim, METH_VARARGS, NULL},
	{ (char *)"DoubleUAHistoNDFunctor___call__", _wrap_DoubleUAHistoNDFunctor___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleUAHistoNDFunctor_interpolationDegree", _wrap_DoubleUAHistoNDFunctor_interpolationDegree, METH_VARARGS, NULL},
	{ (char *)"DoubleUAHistoNDFunctor_setInterpolationDegree", _wrap_DoubleUAHistoNDFunctor_setInterpolationDegree, METH_VARARGS, NULL},
	{ (char *)"DoubleUAHistoNDFunctor_interpolator", _wrap_DoubleUAHistoNDFunctor_interpolator, METH_VARARGS, NULL},
	{ (char *)"DoubleUAHistoNDFunctor_table", _wrap_DoubleUAHistoNDFunctor_table, METH_VARARGS, NULL},
	{ (char *)"DoubleUAHistoNDFunctor_setConverter", _wrap_DoubleUAHistoNDFunctor_setConverter, METH_VARARGS, NULL},
	{ (char *)"DoubleUAHistoNDFunctor_classId", _wrap_DoubleUAHistoNDFunctor_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleUAHistoNDFunctor_write", _wrap_DoubleUAHistoNDFunctor_write, METH_VARARGS, NULL},
	{ (char *)"DoubleUAHistoNDFunctor_classname", _wrap_DoubleUAHistoNDFunctor_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleUAHistoNDFunctor_version", _wrap_DoubleUAHistoNDFunctor_version, METH_VARARGS, NULL},
	{ (char *)"DoubleUAHistoNDFunctor_read", _wrap_DoubleUAHistoNDFunctor_read, METH_VARARGS, NULL},
	{ (char *)"DoubleUAHistoNDFunctor_swigregister", DoubleUAHistoNDFunctor_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_DoubleNUHistoNDFunctor", _wrap_delete_DoubleNUHistoNDFunctor, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoNDFunctor_minDim", _wrap_DoubleNUHistoNDFunctor_minDim, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoNDFunctor___call__", _wrap_DoubleNUHistoNDFunctor___call__, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoNDFunctor_interpolationDegree", _wrap_DoubleNUHistoNDFunctor_interpolationDegree, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoNDFunctor_setInterpolationDegree", _wrap_DoubleNUHistoNDFunctor_setInterpolationDegree, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoNDFunctor_interpolator", _wrap_DoubleNUHistoNDFunctor_interpolator, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoNDFunctor_table", _wrap_DoubleNUHistoNDFunctor_table, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoNDFunctor_setConverter", _wrap_DoubleNUHistoNDFunctor_setConverter, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoNDFunctor_classId", _wrap_DoubleNUHistoNDFunctor_classId, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoNDFunctor_write", _wrap_DoubleNUHistoNDFunctor_write, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoNDFunctor_classname", _wrap_DoubleNUHistoNDFunctor_classname, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoNDFunctor_version", _wrap_DoubleNUHistoNDFunctor_version, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoNDFunctor_read", _wrap_DoubleNUHistoNDFunctor_read, METH_VARARGS, NULL},
	{ (char *)"DoubleNUHistoNDFunctor_swigregister", DoubleNUHistoNDFunctor_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_FloatHistoNDFunctor", _wrap_delete_FloatHistoNDFunctor, METH_VARARGS, NULL},
	{ (char *)"FloatHistoNDFunctor_minDim", _wrap_FloatHistoNDFunctor_minDim, METH_VARARGS, NULL},
	{ (char *)"FloatHistoNDFunctor___call__", _wrap_FloatHistoNDFunctor___call__, METH_VARARGS, NULL},
	{ (char *)"FloatHistoNDFunctor_interpolationDegree", _wrap_FloatHistoNDFunctor_interpolationDegree, METH_VARARGS, NULL},
	{ (char *)"FloatHistoNDFunctor_setInterpolationDegree", _wrap_FloatHistoNDFunctor_setInterpolationDegree, METH_VARARGS, NULL},
	{ (char *)"FloatHistoNDFunctor_interpolator", _wrap_FloatHistoNDFunctor_interpolator, METH_VARARGS, NULL},
	{ (char *)"FloatHistoNDFunctor_table", _wrap_FloatHistoNDFunctor_table, METH_VARARGS, NULL},
	{ (char *)"FloatHistoNDFunctor_setConverter", _wrap_FloatHistoNDFunctor_setConverter, METH_VARARGS, NULL},
	{ (char *)"FloatHistoNDFunctor_classId", _wrap_FloatHistoNDFunctor_classId, METH_VARARGS, NULL},
	{ (char *)"FloatHistoNDFunctor_write", _wrap_FloatHistoNDFunctor_write, METH_VARARGS, NULL},
	{ (char *)"FloatHistoNDFunctor_classname", _wrap_FloatHistoNDFunctor_classname, METH_VARARGS, NULL},
	{ (char *)"FloatHistoNDFunctor_version", _wrap_FloatHistoNDFunctor_version, METH_VARARGS, NULL},
	{ (char *)"FloatHistoNDFunctor_read", _wrap_FloatHistoNDFunctor_read, METH_VARARGS, NULL},
	{ (char *)"FloatHistoNDFunctor_swigregister", FloatHistoNDFunctor_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_FloatUAHistoNDFunctor", _wrap_delete_FloatUAHistoNDFunctor, METH_VARARGS, NULL},
	{ (char *)"FloatUAHistoNDFunctor_minDim", _wrap_FloatUAHistoNDFunctor_minDim, METH_VARARGS, NULL},
	{ (char *)"FloatUAHistoNDFunctor___call__", _wrap_FloatUAHistoNDFunctor___call__, METH_VARARGS, NULL},
	{ (char *)"FloatUAHistoNDFunctor_interpolationDegree", _wrap_FloatUAHistoNDFunctor_interpolationDegree, METH_VARARGS, NULL},
	{ (char *)"FloatUAHistoNDFunctor_setInterpolationDegree", _wrap_FloatUAHistoNDFunctor_setInterpolationDegree, METH_VARARGS, NULL},
	{ (char *)"FloatUAHistoNDFunctor_interpolator", _wrap_FloatUAHistoNDFunctor_interpolator, METH_VARARGS, NULL},
	{ (char *)"FloatUAHistoNDFunctor_table", _wrap_FloatUAHistoNDFunctor_table, METH_VARARGS, NULL},
	{ (char *)"FloatUAHistoNDFunctor_setConverter", _wrap_FloatUAHistoNDFunctor_setConverter, METH_VARARGS, NULL},
	{ (char *)"FloatUAHistoNDFunctor_classId", _wrap_FloatUAHistoNDFunctor_classId, METH_VARARGS, NULL},
	{ (char *)"FloatUAHistoNDFunctor_write", _wrap_FloatUAHistoNDFunctor_write, METH_VARARGS, NULL},
	{ (char *)"FloatUAHistoNDFunctor_classname", _wrap_FloatUAHistoNDFunctor_classname, METH_VARARGS, NULL},
	{ (char *)"FloatUAHistoNDFunctor_version", _wrap_FloatUAHistoNDFunctor_version, METH_VARARGS, NULL},
	{ (char *)"FloatUAHistoNDFunctor_read", _wrap_FloatUAHistoNDFunctor_read, METH_VARARGS, NULL},
	{ (char *)"FloatUAHistoNDFunctor_swigregister", FloatUAHistoNDFunctor_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_FloatNUHistoNDFunctor", _wrap_delete_FloatNUHistoNDFunctor, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoNDFunctor_minDim", _wrap_FloatNUHistoNDFunctor_minDim, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoNDFunctor___call__", _wrap_FloatNUHistoNDFunctor___call__, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoNDFunctor_interpolationDegree", _wrap_FloatNUHistoNDFunctor_interpolationDegree, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoNDFunctor_setInterpolationDegree", _wrap_FloatNUHistoNDFunctor_setInterpolationDegree, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoNDFunctor_interpolator", _wrap_FloatNUHistoNDFunctor_interpolator, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoNDFunctor_table", _wrap_FloatNUHistoNDFunctor_table, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoNDFunctor_setConverter", _wrap_FloatNUHistoNDFunctor_setConverter, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoNDFunctor_classId", _wrap_FloatNUHistoNDFunctor_classId, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoNDFunctor_write", _wrap_FloatNUHistoNDFunctor_write, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoNDFunctor_classname", _wrap_FloatNUHistoNDFunctor_classname, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoNDFunctor_version", _wrap_FloatNUHistoNDFunctor_version, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoNDFunctor_read", _wrap_FloatNUHistoNDFunctor_read, METH_VARARGS, NULL},
	{ (char *)"FloatNUHistoNDFunctor_swigregister", FloatNUHistoNDFunctor_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_StatAccumulatorArr", _wrap_new_StatAccumulatorArr, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_dim", _wrap_StatAccumulatorArr_dim, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_count", _wrap_StatAccumulatorArr_count, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_min", _wrap_StatAccumulatorArr_min, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_max", _wrap_StatAccumulatorArr_max, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_mean", _wrap_StatAccumulatorArr_mean, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_stdev", _wrap_StatAccumulatorArr_stdev, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_meanUncertainty", _wrap_StatAccumulatorArr_meanUncertainty, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_accumulate", _wrap_StatAccumulatorArr_accumulate, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_reset", _wrap_StatAccumulatorArr_reset, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr___add__", _wrap_StatAccumulatorArr___add__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr___eq__", _wrap_StatAccumulatorArr___eq__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr___ne__", _wrap_StatAccumulatorArr___ne__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_classId", _wrap_StatAccumulatorArr_classId, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_write", _wrap_StatAccumulatorArr_write, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_classname", _wrap_StatAccumulatorArr_classname, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_version", _wrap_StatAccumulatorArr_version, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_restore", _wrap_StatAccumulatorArr_restore, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr___mul__", _wrap_StatAccumulatorArr___mul__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr___div__", _wrap_StatAccumulatorArr___div__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr___imul__", _wrap_StatAccumulatorArr___imul__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr___idiv__", _wrap_StatAccumulatorArr___idiv__, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_minArray", _wrap_StatAccumulatorArr_minArray, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_maxArray", _wrap_StatAccumulatorArr_maxArray, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_meanArray", _wrap_StatAccumulatorArr_meanArray, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_stdevArray", _wrap_StatAccumulatorArr_stdevArray, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_meanUncertaintyArray", _wrap_StatAccumulatorArr_meanUncertaintyArray, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr___iadd__", _wrap_StatAccumulatorArr___iadd__, METH_VARARGS, NULL},
	{ (char *)"delete_StatAccumulatorArr", _wrap_delete_StatAccumulatorArr, METH_VARARGS, NULL},
	{ (char *)"StatAccumulatorArr_swigregister", StatAccumulatorArr_swigregister, METH_VARARGS, NULL},
	{ (char *)"convertToHistoAxis", _wrap_convertToHistoAxis, METH_VARARGS, NULL},
	{ (char *)"convertToGridAxis", _wrap_convertToGridAxis, METH_VARARGS, NULL},
	{ (char *)"new_InterpolatedDistribution1D", _wrap_new_InterpolatedDistribution1D, METH_VARARGS, NULL},
	{ (char *)"delete_InterpolatedDistribution1D", _wrap_delete_InterpolatedDistribution1D, METH_VARARGS, NULL},
	{ (char *)"InterpolatedDistribution1D_clone", _wrap_InterpolatedDistribution1D_clone, METH_VARARGS, NULL},
	{ (char *)"InterpolatedDistribution1D_add", _wrap_InterpolatedDistribution1D_add, METH_VARARGS, NULL},
	{ (char *)"InterpolatedDistribution1D_replace", _wrap_InterpolatedDistribution1D_replace, METH_VARARGS, NULL},
	{ (char *)"InterpolatedDistribution1D_setWeight", _wrap_InterpolatedDistribution1D_setWeight, METH_VARARGS, NULL},
	{ (char *)"InterpolatedDistribution1D_clear", _wrap_InterpolatedDistribution1D_clear, METH_VARARGS, NULL},
	{ (char *)"InterpolatedDistribution1D_normalizeAutomatically", _wrap_InterpolatedDistribution1D_normalizeAutomatically, METH_VARARGS, NULL},
	{ (char *)"InterpolatedDistribution1D_size", _wrap_InterpolatedDistribution1D_size, METH_VARARGS, NULL},
	{ (char *)"InterpolatedDistribution1D_expectedSize", _wrap_InterpolatedDistribution1D_expectedSize, METH_VARARGS, NULL},
	{ (char *)"InterpolatedDistribution1D_density", _wrap_InterpolatedDistribution1D_density, METH_VARARGS, NULL},
	{ (char *)"InterpolatedDistribution1D_cdf", _wrap_InterpolatedDistribution1D_cdf, METH_VARARGS, NULL},
	{ (char *)"InterpolatedDistribution1D_exceedance", _wrap_InterpolatedDistribution1D_exceedance, METH_VARARGS, NULL},
	{ (char *)"InterpolatedDistribution1D_quantile", _wrap_InterpolatedDistribution1D_quantile, METH_VARARGS, NULL},
	{ (char *)"InterpolatedDistribution1D_densityAndCdf", _wrap_InterpolatedDistribution1D_densityAndCdf, METH_VARARGS, NULL},
	{ (char *)"InterpolatedDistribution1D_classId", _wrap_InterpolatedDistribution1D_classId, METH_VARARGS, NULL},
	{ (char *)"InterpolatedDistribution1D_classname", _wrap_InterpolatedDistribution1D_classname, METH_VARARGS, NULL},
	{ (char *)"InterpolatedDistribution1D_version", _wrap_InterpolatedDistribution1D_version, METH_VARARGS, NULL},
	{ (char *)"InterpolatedDistribution1D_swigregister", InterpolatedDistribution1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_IntArchivedNtuple", _wrap_new_Ref_IntArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_IntArchivedNtuple", _wrap_delete_Ref_IntArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"Ref_IntArchivedNtuple_retrieve", _wrap_Ref_IntArchivedNtuple_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_IntArchivedNtuple_swigregister", Ref_IntArchivedNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_LLongArchivedNtuple", _wrap_new_Ref_LLongArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_LLongArchivedNtuple", _wrap_delete_Ref_LLongArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongArchivedNtuple_retrieve", _wrap_Ref_LLongArchivedNtuple_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_LLongArchivedNtuple_swigregister", Ref_LLongArchivedNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_UCharArchivedNtuple", _wrap_new_Ref_UCharArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_UCharArchivedNtuple", _wrap_delete_Ref_UCharArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharArchivedNtuple_retrieve", _wrap_Ref_UCharArchivedNtuple_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_UCharArchivedNtuple_swigregister", Ref_UCharArchivedNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_FloatArchivedNtuple", _wrap_new_Ref_FloatArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_FloatArchivedNtuple", _wrap_delete_Ref_FloatArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatArchivedNtuple_retrieve", _wrap_Ref_FloatArchivedNtuple_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_FloatArchivedNtuple_swigregister", Ref_FloatArchivedNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_Ref_DoubleArchivedNtuple", _wrap_new_Ref_DoubleArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"delete_Ref_DoubleArchivedNtuple", _wrap_delete_Ref_DoubleArchivedNtuple, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleArchivedNtuple_retrieve", _wrap_Ref_DoubleArchivedNtuple_retrieve, METH_VARARGS, NULL},
	{ (char *)"Ref_DoubleArchivedNtuple_swigregister", Ref_DoubleArchivedNtuple_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_CompositeGauss1D", _wrap_delete_CompositeGauss1D, METH_VARARGS, NULL},
	{ (char *)"CompositeGauss1D_clone", _wrap_CompositeGauss1D_clone, METH_VARARGS, NULL},
	{ (char *)"CompositeGauss1D_swigregister", CompositeGauss1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_BetaGauss1D", _wrap_delete_BetaGauss1D, METH_VARARGS, NULL},
	{ (char *)"BetaGauss1D_clone", _wrap_BetaGauss1D_clone, METH_VARARGS, NULL},
	{ (char *)"BetaGauss1D_swigregister", BetaGauss1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_LogQuadraticLadder", _wrap_delete_LogQuadraticLadder, METH_VARARGS, NULL},
	{ (char *)"LogQuadraticLadder_clone", _wrap_LogQuadraticLadder_clone, METH_VARARGS, NULL},
	{ (char *)"LogQuadraticLadder_swigregister", LogQuadraticLadder_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_BinnedCompositeJohnson", _wrap_delete_BinnedCompositeJohnson, METH_VARARGS, NULL},
	{ (char *)"BinnedCompositeJohnson_clone", _wrap_BinnedCompositeJohnson_clone, METH_VARARGS, NULL},
	{ (char *)"BinnedCompositeJohnson_swigregister", BinnedCompositeJohnson_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_JohnsonLadder", _wrap_delete_JohnsonLadder, METH_VARARGS, NULL},
	{ (char *)"JohnsonLadder_clone", _wrap_JohnsonLadder_clone, METH_VARARGS, NULL},
	{ (char *)"JohnsonLadder_swigregister", JohnsonLadder_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_PolyFilter1D", _wrap_new_PolyFilter1D, METH_VARARGS, NULL},
	{ (char *)"PolyFilter1D_peakPosition", _wrap_PolyFilter1D_peakPosition, METH_VARARGS, NULL},
	{ (char *)"PolyFilter1D___eq__", _wrap_PolyFilter1D___eq__, METH_VARARGS, NULL},
	{ (char *)"PolyFilter1D___ne__", _wrap_PolyFilter1D___ne__, METH_VARARGS, NULL},
	{ (char *)"PolyFilter1D_classId", _wrap_PolyFilter1D_classId, METH_VARARGS, NULL},
	{ (char *)"PolyFilter1D_write", _wrap_PolyFilter1D_write, METH_VARARGS, NULL},
	{ (char *)"PolyFilter1D_classname", _wrap_PolyFilter1D_classname, METH_VARARGS, NULL},
	{ (char *)"PolyFilter1D_version", _wrap_PolyFilter1D_version, METH_VARARGS, NULL},
	{ (char *)"PolyFilter1D_read", _wrap_PolyFilter1D_read, METH_VARARGS, NULL},
	{ (char *)"delete_PolyFilter1D", _wrap_delete_PolyFilter1D, METH_VARARGS, NULL},
	{ (char *)"PolyFilter1D_swigregister", PolyFilter1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsFilter1DBuilder", _wrap_delete_AbsFilter1DBuilder, METH_VARARGS, NULL},
	{ (char *)"AbsFilter1DBuilder_centralWeightLength", _wrap_AbsFilter1DBuilder_centralWeightLength, METH_VARARGS, NULL},
	{ (char *)"AbsFilter1DBuilder_keepAllFilters", _wrap_AbsFilter1DBuilder_keepAllFilters, METH_VARARGS, NULL},
	{ (char *)"AbsFilter1DBuilder_makeFilter", _wrap_AbsFilter1DBuilder_makeFilter, METH_VARARGS, NULL},
	{ (char *)"AbsFilter1DBuilder_lastBandwidthFactor", _wrap_AbsFilter1DBuilder_lastBandwidthFactor, METH_VARARGS, NULL},
	{ (char *)"AbsFilter1DBuilder_swigregister", AbsFilter1DBuilder_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_OrthoPolyFilter1DBuilder", _wrap_delete_OrthoPolyFilter1DBuilder, METH_VARARGS, NULL},
	{ (char *)"OrthoPolyFilter1DBuilder_makeFilter", _wrap_OrthoPolyFilter1DBuilder_makeFilter, METH_VARARGS, NULL},
	{ (char *)"OrthoPolyFilter1DBuilder_makeOrthoPoly", _wrap_OrthoPolyFilter1DBuilder_makeOrthoPoly, METH_VARARGS, NULL},
	{ (char *)"OrthoPolyFilter1DBuilder_swigregister", OrthoPolyFilter1DBuilder_swigregister, METH_VARARGS, NULL},
	{ (char *)"delete_AbsBoundaryFilter1DBuilder", _wrap_delete_AbsBoundaryFilter1DBuilder, METH_VARARGS, NULL},
	{ (char *)"AbsBoundaryFilter1DBuilder_centralWeightLength", _wrap_AbsBoundaryFilter1DBuilder_centralWeightLength, METH_VARARGS, NULL},
	{ (char *)"AbsBoundaryFilter1DBuilder_keepAllFilters", _wrap_AbsBoundaryFilter1DBuilder_keepAllFilters, METH_VARARGS, NULL},
	{ (char *)"AbsBoundaryFilter1DBuilder_makeOrthoPoly", _wrap_AbsBoundaryFilter1DBuilder_makeOrthoPoly, METH_VARARGS, NULL},
	{ (char *)"AbsBoundaryFilter1DBuilder_isFolding", _wrap_AbsBoundaryFilter1DBuilder_isFolding, METH_VARARGS, NULL},
	{ (char *)"AbsBoundaryFilter1DBuilder_lastBandwidthFactor", _wrap_AbsBoundaryFilter1DBuilder_lastBandwidthFactor, METH_VARARGS, NULL},
	{ (char *)"AbsBoundaryFilter1DBuilder_swigregister", AbsBoundaryFilter1DBuilder_swigregister, METH_VARARGS, NULL},
	{ (char *)"getBoundaryFilter1DBuilder", _wrap_getBoundaryFilter1DBuilder, METH_VARARGS, NULL},
	{ (char *)"new_LocalPolyFilter1D", _wrap_new_LocalPolyFilter1D, METH_VARARGS, NULL},
	{ (char *)"delete_LocalPolyFilter1D", _wrap_delete_LocalPolyFilter1D, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D___eq__", _wrap_LocalPolyFilter1D___eq__, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D___ne__", _wrap_LocalPolyFilter1D___ne__, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D_taper", _wrap_LocalPolyFilter1D_taper, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D_maxDegree", _wrap_LocalPolyFilter1D_maxDegree, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D_dataLen", _wrap_LocalPolyFilter1D_dataLen, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D_getBandwidthFactors", _wrap_LocalPolyFilter1D_getBandwidthFactors, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D_selfContribution", _wrap_LocalPolyFilter1D_selfContribution, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D_getFilter", _wrap_LocalPolyFilter1D_getFilter, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D_getFilterMatrix", _wrap_LocalPolyFilter1D_getFilterMatrix, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D_classId", _wrap_LocalPolyFilter1D_classId, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D_write", _wrap_LocalPolyFilter1D_write, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D_classname", _wrap_LocalPolyFilter1D_classname, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D_version", _wrap_LocalPolyFilter1D_version, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D_read", _wrap_LocalPolyFilter1D_read, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D_doublyStochasticFilter", _wrap_LocalPolyFilter1D_doublyStochasticFilter, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D_eigenGroomedFilter", _wrap_LocalPolyFilter1D_eigenGroomedFilter, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D_filter", _wrap_LocalPolyFilter1D_filter, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D_convolve", _wrap_LocalPolyFilter1D_convolve, METH_VARARGS, NULL},
	{ (char *)"LocalPolyFilter1D_swigregister", LocalPolyFilter1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"new_DummyLocalPolyFilter1D", _wrap_new_DummyLocalPolyFilter1D, METH_VARARGS, NULL},
	{ (char *)"delete_DummyLocalPolyFilter1D", _wrap_delete_DummyLocalPolyFilter1D, METH_VARARGS, NULL},
	{ (char *)"DummyLocalPolyFilter1D_classId", _wrap_DummyLocalPolyFilter1D_classId, METH_VARARGS, NULL},
	{ (char *)"DummyLocalPolyFilter1D_write", _wrap_DummyLocalPolyFilter1D_write, METH_VARARGS, NULL},
	{ (char *)"DummyLocalPolyFilter1D_classname", _wrap_DummyLocalPolyFilter1D_classname, METH_VARARGS, NULL},
	{ (char *)"DummyLocalPolyFilter1D_version", _wrap_DummyLocalPolyFilter1D_version, METH_VARARGS, NULL},
	{ (char *)"DummyLocalPolyFilter1D_read", _wrap_DummyLocalPolyFilter1D_read, METH_VARARGS, NULL},
	{ (char *)"DummyLocalPolyFilter1D_swigregister", DummyLocalPolyFilter1D_swigregister, METH_VARARGS, NULL},
	{ (char *)"symbetaWeightAt0", _wrap_symbetaWeightAt0, METH_VARARGS, NULL},
	{ (char *)"symbetaLOrPEFilter1D", _wrap_symbetaLOrPEFilter1D, METH_VARARGS, NULL},
	{ (char *)"delete_ScalableGaussND", _wrap_delete_ScalableGaussND, METH_VARARGS, NULL},
	{ (char *)"ScalableGaussND_clone", _wrap_ScalableGaussND_clone, METH_VARARGS, NULL},
	{ (char *)"ScalableGaussND_mappedByQuantiles", _wrap_ScalableGaussND_mappedByQuantiles, METH_VARARGS, NULL},
	{ (char *)"ScalableGaussND_classId", _wrap_ScalableGaussND_classId, METH_VARARGS, NULL},
	{ (char *)"ScalableGaussND_write", _wrap_ScalableGaussND_write, METH_VARARGS, NULL},
	{ (char *)"ScalableGaussND_classname", _wrap_ScalableGaussND_classname, METH_VARARGS, NULL},
	{ (char *)"ScalableGaussND_version", _wrap_ScalableGaussND_version, METH_VARARGS, NULL},
	{ (char *)"ScalableGaussND_read", _wrap_ScalableGaussND_read, METH_VARARGS, NULL},
	{ (char *)"new_ScalableGaussND", _wrap_new_ScalableGaussND, METH_VARARGS, NULL},
	{ (char *)"ScalableGaussND_swigregister", ScalableGaussND_swigregister, METH_VARARGS, NULL},
	{ (char *)"inverseGaussCdf", _wrap_inverseGaussCdf, METH_VARARGS, NULL},
	{ (char *)"incompleteBeta", _wrap_incompleteBeta, METH_VARARGS, NULL},
	{ (char *)"inverseIncompleteBeta", _wrap_inverseIncompleteBeta, METH_VARARGS, NULL},
	{ (char *)"Gamma", _wrap_Gamma, METH_VARARGS, NULL},
	{ (char *)"incompleteGamma", _wrap_incompleteGamma, METH_VARARGS, NULL},
	{ (char *)"incompleteGammaC", _wrap_incompleteGammaC, METH_VARARGS, NULL},
	{ (char *)"inverseIncompleteGamma", _wrap_inverseIncompleteGamma, METH_VARARGS, NULL},
	{ (char *)"inverseIncompleteGammaC", _wrap_inverseIncompleteGammaC, METH_VARARGS, NULL},
	{ (char *)"dawsonIntegral", _wrap_dawsonIntegral, METH_VARARGS, NULL},
	{ (char *)"inverseExpsqIntegral", _wrap_inverseExpsqIntegral, METH_VARARGS, NULL},
	{ (char *)"normalDensityDerivative", _wrap_normalDensityDerivative, METH_VARARGS, NULL},
	{ (char *)"bivariateNormalIntegral", _wrap_bivariateNormalIntegral, METH_VARARGS, NULL},
	{ (char *)"new_Peak2D", _wrap_new_Peak2D, METH_VARARGS, NULL},
	{ (char *)"Peak2D_rescaleCoords", _wrap_Peak2D_rescaleCoords, METH_VARARGS, NULL},
	{ (char *)"Peak2D_x_set", _wrap_Peak2D_x_set, METH_VARARGS, NULL},
	{ (char *)"Peak2D_x_get", _wrap_Peak2D_x_get, METH_VARARGS, NULL},
	{ (char *)"Peak2D_y_set", _wrap_Peak2D_y_set, METH_VARARGS, NULL},
	{ (char *)"Peak2D_y_get", _wrap_Peak2D_y_get, METH_VARARGS, NULL},
	{ (char *)"Peak2D_magnitude_set", _wrap_Peak2D_magnitude_set, METH_VARARGS, NULL},
	{ (char *)"Peak2D_magnitude_get", _wrap_Peak2D_magnitude_get, METH_VARARGS, NULL},
	{ (char *)"Peak2D_hessian_set", _wrap_Peak2D_hessian_set, METH_VARARGS, NULL},
	{ (char *)"Peak2D_hessian_get", _wrap_Peak2D_hessian_get, METH_VARARGS, NULL},
	{ (char *)"Peak2D_valid_set", _wrap_Peak2D_valid_set, METH_VARARGS, NULL},
	{ (char *)"Peak2D_valid_get", _wrap_Peak2D_valid_get, METH_VARARGS, NULL},
	{ (char *)"Peak2D_inside_set", _wrap_Peak2D_inside_set, METH_VARARGS, NULL},
	{ (char *)"Peak2D_inside_get", _wrap_Peak2D_inside_get, METH_VARARGS, NULL},
	{ (char *)"delete_Peak2D", _wrap_delete_Peak2D, METH_VARARGS, NULL},
	{ (char *)"Peak2D_swigregister", Peak2D_swigregister, METH_VARARGS, NULL},
	{ (char *)"findPeak3by3", _wrap_findPeak3by3, METH_VARARGS, NULL},
	Index: trunk/npstat/stat/AbsMarginalSmootherBase.hh
	===================================================================
	--- trunk/npstat/stat/AbsMarginalSmootherBase.hh (revision 618)
	+++ trunk/npstat/stat/AbsMarginalSmootherBase.hh (revision 619)
	@@ -1,197 +1,197 @@
	#ifndef NPSTAT_ABSMARGINALSMOOTHERBASE_HH_
	#define NPSTAT_ABSMARGINALSMOOTHERBASE_HH_

	/*!
	// \file AbsMarginalSmootherBase.hh
	//
	// \brief Interface definition for 1-d nonparametric density estimation
	//
	// Author: I. Volobouev
	//
	// June 2015
	*/

	#include <vector>
	#include <utility>
	#include <limits>
	#include <cassert>
	#include <stdexcept>

	#include "geners/AbsArchive.hh"
	#include "npstat/stat/HistoND.hh"

	namespace npstat {
	class AbsMarginalSmootherBase
	{
	public:
	/** Constructor takes binning parameters for the internal histogram */
	AbsMarginalSmootherBase(unsigned nbins, double xmin, double xmax,
	const char* axisLabel = 0);

	inline virtual ~AbsMarginalSmootherBase() {delete histo_;}

	void setAxisLabel(const char* axisLabel);

	//@{
	/** Simple inspector of the object properties */
	inline unsigned nBins() const {return nbins_;}
	inline double xMin() const {return xmin_;}
	inline double xMax() const {return xmax_;}
	inline double binWidth() const {return (xmax_ - xmin_)/nbins_;}
	inline const std::string& getAxisLabel() const {return axlabel_;}
	//@}

	/**
	// The bandwidth used by the most recent "smooth" or
	// "weightedSmooth" call
	*/
	inline double lastBandwidth() const {return lastBw_;}

	/** Set the archive for storing original and smoothed histograms */
	void setArchive(gs::AbsArchive* ar, const char* category = 0);

	/** Stop storing histograms */
	inline void unsetArchive() {setArchive(0);}

	/**
	// Smoothing function for unweighted samples. The region
	// used for smoothing will be defined by the overlap of
	// the intervals [minValue, maxValue) and [xMin(), xMax()).
	*/
	template <typename Numeric>
	const HistoND<double>& smooth(
	const std::vector<Numeric>& inputPoints,
	double minValue = -std::numeric_limits<double>::max(),
	double maxValue = std::numeric_limits<double>::max(),
	double* bandwidthUsed = 0);

	/**
	// Smoothing function for unweighted samples. The region
	// used for smoothing will be defined by the overlap of
	// the intervals [minValue, maxValue) and [xMin(), xMax()).
	// Parameters "uniqueId" and "dimNumber" are used for
	// identification purposes only -- they will be used to
	// create the item name in the archive if the archive is set.
	*/
	template <typename Numeric>
	const HistoND<double>& smooth(
	unsigned long uniqueId, unsigned dimNumber,
	const std::vector<Numeric>& inputPoints,
	double minValue = -std::numeric_limits<double>::max(),
	double maxValue = std::numeric_limits<double>::max(),
	double* bandwidthUsed = 0);

	/**
	// Smoothing function for weighted samples. The region
	// used for smoothing will be defined by the overlap of
	// the intervals [minValue, maxValue) and [xMin(), xMax()).
	*/
	template <typename Numeric>
	const HistoND<double>& weightedSmooth(
	const std::vector<std::pair<Numeric,double> >& inputPoints,
	double minValue = -std::numeric_limits<double>::max(),
	double maxValue = std::numeric_limits<double>::max(),
	double* bandwidthUsed = 0);

	/**
	// Smoothing function for weighted samples. The region
	// used for smoothing will be defined by the overlap of
	// the intervals [minValue, maxValue) and [xMin(), xMax()).
	// Parameters "uniqueId" and "multivariatePointDimNumber"
	// are used for identification purposes only -- they will be used
	// to create the item name in the archive if the archive is set.
	*/
	template <typename Numeric>
	const HistoND<double>& weightedSmooth(
	unsigned long uniqueId, unsigned multivariatePointDimNumber,
	const std::vector<std::pair<Numeric,double> >& inputPoints,
	double minValue = -std::numeric_limits<double>::max(),
	double maxValue = std::numeric_limits<double>::max(),
	double* bandwidthUsed = 0);

	private:
	AbsMarginalSmootherBase();
	AbsMarginalSmootherBase(const AbsMarginalSmootherBase&);
	AbsMarginalSmootherBase& operator=(const AbsMarginalSmootherBase&);

	HistoND<double>& clearHisto(double xmin, double xmax);
	void storeHisto(unsigned long uniqueId, unsigned dim, double bw) const;

	// Method to implement in derived classes
	virtual void smoothHisto(HistoND<double>& histo,
	double effectiveSampleSize,
	double* bandwidthUsed,
	bool isSampleWeighted) = 0;
	HistoND<double>* histo_;
	double xmin_;
	double xmax_;
	double lastBw_;
	gs::AbsArchive* ar_;
	std::string category_;
	std::string axlabel_;
	unsigned nbins_;

	#ifdef SWIG
	public:
	/** Simplified smooth method without archiving */
	template <typename Vec>
	- inline HistoND<double> smooth2(
	- const Vec& inputPoints,
	- double *OUTPUT)
	+ inline HistoND<double,HistoAxis>* smooth2(
	+ const Vec& inputPoints, double *OUTPUT)
	{
	assert(OUTPUT);
	- const HistoND<double>& h = smooth(inputPoints);
	+ HistoND<double,HistoAxis>* p = new HistoND<double,HistoAxis>(
	+ smooth(inputPoints));
	*OUTPUT = lastBw_;
	- return h;
	+ return p;
	}

	/** Simplified smooth method with archiving */
	template <typename Vec>
	- inline HistoND<double> smoothArch(
	- const Vec& inputPoints,
	- unsigned long uniqueId, unsigned dimNumber,
	+ inline HistoND<double,HistoAxis>* smoothArch(
	+ const Vec& inputPoints, unsigned long uniqueId, unsigned dimNumber,
	double *OUTPUT)
	{
	assert(OUTPUT);
	if (!ar_) throw std::runtime_error(
	"In npstat::AbsMarginalSmootherBase::smoothArch: "
	"archive is not set");
	- const HistoND<double>& h = smooth(uniqueId, dimNumber, inputPoints);
	+ HistoND<double,HistoAxis>* p = new HistoND<double,HistoAxis>(
	+ smooth(uniqueId, dimNumber, inputPoints));
	*OUTPUT = lastBw_;
	- return h;
	+ return p;
	}

	/** Simplified smooth method for weigted samples without archiving */
	template <typename Vec>
	- inline HistoND<double> weightedSmooth2(
	- const Vec& inputPoints,
	- double *OUTPUT)
	+ inline HistoND<double,HistoAxis>* weightedSmooth2(
	+ const Vec& inputPoints, double *OUTPUT)
	{
	assert(OUTPUT);
	- const HistoND<double>& h = weightedSmooth(inputPoints);
	+ HistoND<double,HistoAxis>* p = new HistoND<double,HistoAxis>(
	+ weightedSmooth(inputPoints));
	*OUTPUT = lastBw_;
	- return h;
	+ return p;
	}

	/** Simplified smooth method for weigted samples with archiving */
	template <typename Vec>
	- inline HistoND<double> weightedSmoothArch(
	- const Vec& inputPoints,
	- unsigned long uniqueId, unsigned dimNumber,
	+ inline HistoND<double,HistoAxis>* weightedSmoothArch(
	+ const Vec& inputPoints, unsigned long uniqueId, unsigned dimNumber,
	double *OUTPUT)
	{
	assert(OUTPUT);
	if (!ar_) throw std::runtime_error(
	"In npstat::AbsMarginalSmootherBase::weightedSmoothArch: "
	"archive is not set");
	- const HistoND<double>& h = weightedSmooth(uniqueId, dimNumber, inputPoints);
	+ HistoND<double,HistoAxis>* p = new HistoND<double,HistoAxis>(
	+ weightedSmooth(uniqueId, dimNumber, inputPoints));
	*OUTPUT = lastBw_;
	- return h;
	+ return p;
	}
	#endif // SWIG
	};
	}

	#include "npstat/stat/AbsMarginalSmootherBase.icc"

	#endif // NPSTAT_ABSMARGINALSMOOTHERBASE_HH_

File Metadata

Mime Type: application/octet-stream
Expires: Fri, Apr 26, 11:27 AM (1 d, 23 h)
Storage Engine: chunks
Storage Format: Chunks
Storage Handle: 7TTWoedUN6Dm
Default Alt Text: (7 MB)

Offset	End	Complete
0	4194304	Yes
4194304	8300539	Yes

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions